diff --git a/build.gradle b/build.gradle
index 9a33213..9fc6e77 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,16 +1,9 @@
plugins {
id("com.github.johnrengelman.shadow") version "8.1.1" apply(false)
- id("io.micronaut.application") version "${micronautGradlePluginVersion}" apply(false)
- id("io.micronaut.aot") version "${micronautGradlePluginVersion}" apply(false)
- id("io.micronaut.docker") version "${micronautGradlePluginVersion}" apply(false)
- id("com.google.protobuf") version "0.9.4" apply(false)
id("maven-publish")
id("com.diffplug.spotless") version "7.0.3"
- id("com.autonomousapps.dependency-analysis") version "2.17.0"
}
-
-
repositories {
mavenCentral()
}
@@ -19,7 +12,7 @@ allprojects {
apply plugin: 'java'
apply plugin: 'maven-publish'
apply plugin: 'com.diffplug.spotless'
- apply plugin: 'com.autonomousapps.dependency-analysis'
+
repositories {
mavenCentral()
maven {
@@ -28,9 +21,12 @@ allprojects {
}
}
+ java {
+ sourceCompatibility = JavaVersion.toVersion("21")
+ targetCompatibility = JavaVersion.toVersion("21")
+ }
+
dependencies {
- implementation 'ch.qos.logback:logback-classic:1.5.17'
- implementation 'ch.qos.logback:logback-core:1.5.17'
implementation 'org.slf4j:slf4j-api:2.0.17'
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
@@ -38,6 +34,11 @@ allprojects {
testImplementation 'org.junit.jupiter:junit-jupiter-params:5.8.2'
testImplementation 'org.mockito:mockito-core:4.0.0'
}
+
+ test {
+ useJUnitPlatform()
+ }
+
publishing {
publications {
maven(MavenPublication) {
@@ -56,17 +57,16 @@ allprojects {
}
}
}
+
jar {
manifest {
attributes 'Implementation-Version': project.version
}
}
- spotless {
+ spotless {
format 'misc', {
- // define the files to apply `misc` to
target '*.gradle', '.gitattributes', '.gitignore'
-
trimTrailingWhitespace()
leadingSpacesToTabs()
endWithNewline()
@@ -74,22 +74,7 @@ allprojects {
java {
googleJavaFormat()
formatAnnotations()
- licenseHeader('''/*
- * (C) 2017-$YEAR TCN Inc. All rights reserved.
- *
- * Licensed 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
- *
- * https://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.
- *
- */''')
+ targetExclude("build/**")
}
}
}
diff --git a/config/build.gradle b/config/build.gradle
new file mode 100644
index 0000000..72e62ce
--- /dev/null
+++ b/config/build.gradle
@@ -0,0 +1,11 @@
+plugins {
+ id("java-library")
+ id("maven-publish")
+}
+
+dependencies {
+ api(project(':core'))
+
+ // File watching — the only external dependency beyond core.
+ implementation("io.methvin:directory-watcher:0.18.0")
+}
diff --git a/config/src/main/java/com/tcn/exile/config/CertificateRotator.java b/config/src/main/java/com/tcn/exile/config/CertificateRotator.java
new file mode 100644
index 0000000..d95185a
--- /dev/null
+++ b/config/src/main/java/com/tcn/exile/config/CertificateRotator.java
@@ -0,0 +1,113 @@
+package com.tcn.exile.config;
+
+import com.tcn.exile.ExileConfig;
+import java.io.ByteArrayInputStream;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.HexFormat;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Checks certificate expiration and rotates via the gate config service.
+ *
+ *
Intended to be called periodically (e.g., every hour). If the certificate expires within the
+ * configured threshold (default 10 days), it calls the gate service to rotate and writes the new
+ * certificate to the config file.
+ */
+public final class CertificateRotator {
+
+ private static final Logger log = LoggerFactory.getLogger(CertificateRotator.class);
+ private static final int DEFAULT_RENEWAL_DAYS = 10;
+
+ private final ExileClientManager manager;
+ private final int renewalDays;
+
+ public CertificateRotator(ExileClientManager manager) {
+ this(manager, DEFAULT_RENEWAL_DAYS);
+ }
+
+ public CertificateRotator(ExileClientManager manager, int renewalDays) {
+ this.manager = manager;
+ this.renewalDays = renewalDays;
+ }
+
+ /**
+ * Check and rotate if needed. Returns true if rotation was performed.
+ *
+ *
Call this periodically (e.g., hourly).
+ */
+ public boolean checkAndRotate() {
+ var client = manager.client();
+ if (client == null) return false;
+
+ var config = client.config();
+ Instant expiration = getCertExpiration(config);
+ if (expiration == null) {
+ log.warn("Could not determine certificate expiration date");
+ return false;
+ }
+
+ var now = Instant.now();
+ if (expiration.isBefore(now)) {
+ log.error("Certificate has expired ({}). Manual renewal required.", expiration);
+ manager.stop();
+ return false;
+ }
+
+ if (expiration.isBefore(now.plus(renewalDays, ChronoUnit.DAYS))) {
+ log.info("Certificate expires at {}, attempting rotation", expiration);
+ try {
+ var hash = getCertFingerprint(config);
+ var newCert = client.config_().rotateCertificate(hash);
+ if (newCert != null && !newCert.isEmpty()) {
+ manager.configWatcher().writeConfig(newCert);
+ log.info("Certificate rotated successfully");
+ return true;
+ } else {
+ log.warn("Certificate rotation returned empty response");
+ }
+ } catch (Exception e) {
+ log.error("Certificate rotation failed: {}", e.getMessage());
+ }
+ } else {
+ log.debug(
+ "Certificate valid until {}, no rotation needed ({} day threshold)",
+ expiration,
+ renewalDays);
+ }
+ return false;
+ }
+
+ static Instant getCertExpiration(ExileConfig config) {
+ try {
+ var cf = CertificateFactory.getInstance("X.509");
+ var cert =
+ (X509Certificate)
+ cf.generateCertificate(
+ new ByteArrayInputStream(config.publicCert().getBytes(StandardCharsets.UTF_8)));
+ return cert.getNotAfter().toInstant();
+ } catch (Exception e) {
+ return null;
+ }
+ }
+
+ static String getCertFingerprint(ExileConfig config) {
+ try {
+ var cf = CertificateFactory.getInstance("X.509");
+ var cert =
+ (X509Certificate)
+ cf.generateCertificate(
+ new ByteArrayInputStream(config.publicCert().getBytes(StandardCharsets.UTF_8)));
+ var digest = MessageDigest.getInstance("SHA-256");
+ var hash = digest.digest(cert.getEncoded());
+ return HexFormat.of().withDelimiter(":").formatHex(hash);
+ } catch (Exception e) {
+ return "";
+ }
+ }
+}
diff --git a/config/src/main/java/com/tcn/exile/config/ConfigFileWatcher.java b/config/src/main/java/com/tcn/exile/config/ConfigFileWatcher.java
new file mode 100644
index 0000000..08ae746
--- /dev/null
+++ b/config/src/main/java/com/tcn/exile/config/ConfigFileWatcher.java
@@ -0,0 +1,168 @@
+package com.tcn.exile.config;
+
+import com.tcn.exile.ExileConfig;
+import io.methvin.watcher.DirectoryWatcher;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Watches the config directory for changes to the exile config file and invokes a callback.
+ *
+ *
Replaces the 400+ line ConfigChangeWatcher that was copy-pasted across all integrations.
+ *
+ *
The watcher monitors the standard config file ({@code com.tcn.exiles.sati.config.cfg}) in the
+ * standard directories ({@code /workdir/config} and {@code workdir/config}). On create/modify, it
+ * parses the file and calls the configured {@link Listener}. On delete, it calls {@link
+ * Listener#onConfigRemoved()}.
+ */
+public final class ConfigFileWatcher implements AutoCloseable {
+
+ private static final Logger log = LoggerFactory.getLogger(ConfigFileWatcher.class);
+ static final String CONFIG_FILE_NAME = "com.tcn.exiles.sati.config.cfg";
+ private static final List DEFAULT_WATCH_DIRS =
+ List.of(Path.of("/workdir/config"), Path.of("workdir/config"));
+
+ private final List watchDirs;
+ private final Listener listener;
+ private final AtomicBoolean started = new AtomicBoolean(false);
+ private volatile DirectoryWatcher watcher;
+ private volatile Path configDir;
+
+ /** Callback interface for config change events. */
+ public interface Listener {
+ /** Called when a new or updated config is detected. */
+ void onConfigChanged(ExileConfig config);
+
+ /** Called when the config file is deleted. */
+ void onConfigRemoved();
+ }
+
+ private ConfigFileWatcher(List watchDirs, Listener listener) {
+ this.watchDirs = watchDirs;
+ this.listener = listener;
+ }
+
+ public static ConfigFileWatcher create(Listener listener) {
+ return new ConfigFileWatcher(DEFAULT_WATCH_DIRS, listener);
+ }
+
+ public static ConfigFileWatcher create(List watchDirs, Listener listener) {
+ return new ConfigFileWatcher(watchDirs, listener);
+ }
+
+ /**
+ * Start watching. Reads any existing config file immediately, then watches for changes
+ * asynchronously. Call this once.
+ */
+ public void start() throws IOException {
+ if (!started.compareAndSet(false, true)) {
+ throw new IllegalStateException("Already started");
+ }
+
+ // Find or create the config directory.
+ configDir = watchDirs.stream().filter(p -> p.toFile().exists()).findFirst().orElse(null);
+ if (configDir == null) {
+ var fallback = watchDirs.get(0);
+ if (fallback.toFile().mkdirs()) {
+ configDir = fallback;
+ log.info("Created config directory: {}", configDir);
+ } else {
+ log.warn("Could not find or create config directory from: {}", watchDirs);
+ }
+ } else {
+ log.info("Using config directory: {}", configDir);
+ }
+
+ // Read existing config if present.
+ loadExistingConfig();
+
+ // Start watching.
+ var existingDirs = watchDirs.stream().filter(p -> p.toFile().exists()).toList();
+ if (existingDirs.isEmpty()) {
+ log.warn("No config directories exist to watch");
+ return;
+ }
+
+ watcher =
+ DirectoryWatcher.builder()
+ .paths(existingDirs)
+ .fileHashing(false)
+ .listener(
+ event -> {
+ if (!event.path().getFileName().toString().equals(CONFIG_FILE_NAME)) return;
+ switch (event.eventType()) {
+ case CREATE, MODIFY -> handleConfigFileChange(event.path());
+ case DELETE -> {
+ log.info("Config file deleted");
+ listener.onConfigRemoved();
+ }
+ default -> log.debug("Ignoring event: {}", event.eventType());
+ }
+ })
+ .build();
+ watcher.watchAsync();
+ log.info("Config file watcher started");
+ }
+
+ /** Returns the directory where the config file was found or created. */
+ public Path configDir() {
+ return configDir;
+ }
+
+ /**
+ * Write a config string (e.g., a rotated certificate) to the config file. This triggers the
+ * watcher to reload.
+ */
+ public void writeConfig(String content) throws IOException {
+ if (configDir == null) {
+ throw new IllegalStateException("No config directory available");
+ }
+ var file = configDir.resolve(CONFIG_FILE_NAME);
+ Files.writeString(file, content);
+ log.info("Wrote config file: {}", file);
+ }
+
+ private void loadExistingConfig() {
+ if (configDir == null) return;
+ var file = configDir.resolve(CONFIG_FILE_NAME);
+ if (file.toFile().exists()) {
+ ConfigParser.parse(file)
+ .ifPresent(
+ config -> {
+ log.info("Loaded existing config for org={}", config.org());
+ listener.onConfigChanged(config);
+ });
+ }
+ }
+
+ private void handleConfigFileChange(Path path) {
+ if (!path.toFile().canRead()) {
+ log.warn("Config file not readable: {}", path);
+ return;
+ }
+ ConfigParser.parse(path)
+ .ifPresentOrElse(
+ config -> {
+ log.info("Config changed for org={}", config.org());
+ listener.onConfigChanged(config);
+ },
+ () -> log.warn("Failed to parse config file: {}", path));
+ }
+
+ @Override
+ public void close() {
+ if (watcher != null) {
+ try {
+ watcher.close();
+ log.info("Config file watcher closed");
+ } catch (IOException e) {
+ log.warn("Error closing config file watcher", e);
+ }
+ }
+ }
+}
diff --git a/config/src/main/java/com/tcn/exile/config/ConfigParser.java b/config/src/main/java/com/tcn/exile/config/ConfigParser.java
new file mode 100644
index 0000000..50a108f
--- /dev/null
+++ b/config/src/main/java/com/tcn/exile/config/ConfigParser.java
@@ -0,0 +1,177 @@
+package com.tcn.exile.config;
+
+import com.tcn.exile.ExileConfig;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Base64;
+import java.util.Map;
+import java.util.Optional;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Parses the Base64-encoded JSON config file used by all exile integrations.
+ *
+ *
The file format is a Base64-encoded JSON object with fields: {@code ca_certificate}, {@code
+ * certificate}, {@code private_key}, and {@code api_endpoint} (as {@code hostname:port}).
+ */
+public final class ConfigParser {
+
+ private static final Logger log = LoggerFactory.getLogger(ConfigParser.class);
+
+ private ConfigParser() {}
+
+ /** Parse a config file at the given path. Returns empty if the file can't be parsed. */
+ public static Optional parse(Path path) {
+ try {
+ var bytes = Files.readAllBytes(path);
+ return parse(bytes);
+ } catch (Exception e) {
+ log.warn("Failed to read config file {}: {}", path, e.getMessage());
+ return Optional.empty();
+ }
+ }
+
+ /** Parse config from raw bytes (Base64-encoded JSON). */
+ public static Optional parse(byte[] raw) {
+ try {
+ // Trim trailing whitespace/newline that some editors add.
+ var trimmed = new String(raw, StandardCharsets.UTF_8).trim().getBytes(StandardCharsets.UTF_8);
+
+ // Try Base64 decode; if it fails, try as-is (already decoded).
+ byte[] json;
+ try {
+ json = Base64.getDecoder().decode(trimmed);
+ } catch (IllegalArgumentException e) {
+ json = trimmed;
+ }
+
+ var map = parseJson(json);
+ if (map == null) return Optional.empty();
+
+ var rootCert = (String) map.get("ca_certificate");
+ var publicCert = (String) map.get("certificate");
+ var privateKey = (String) map.get("private_key");
+ var endpoint = (String) map.get("api_endpoint");
+
+ if (rootCert == null || publicCert == null || privateKey == null) {
+ log.warn("Config missing required certificate fields");
+ return Optional.empty();
+ }
+
+ var builder =
+ ExileConfig.builder().rootCert(rootCert).publicCert(publicCert).privateKey(privateKey);
+
+ var certName = (String) map.get("certificate_name");
+ if (certName != null) builder.certificateName(certName);
+
+ if (endpoint != null && !endpoint.isEmpty()) {
+ // Handle both "host:port" and URL formats like "https://host" or "https://host:port".
+ String host = endpoint;
+ int port = 443;
+ if (host.contains("://")) {
+ // Strip scheme (https://, http://).
+ host = host.substring(host.indexOf("://") + 3);
+ }
+ // Strip trailing slashes.
+ if (host.endsWith("/")) {
+ host = host.substring(0, host.length() - 1);
+ }
+ // Split host:port.
+ int colonIdx = host.lastIndexOf(':');
+ if (colonIdx > 0) {
+ try {
+ port = Integer.parseInt(host.substring(colonIdx + 1));
+ host = host.substring(0, colonIdx);
+ } catch (NumberFormatException e) {
+ // No valid port — use host as-is with default port.
+ }
+ }
+ builder.apiHostname(host);
+ builder.apiPort(port);
+ }
+
+ return Optional.of(builder.build());
+ } catch (Exception e) {
+ log.warn("Failed to parse config: {}", e.getMessage());
+ return Optional.empty();
+ }
+ }
+
+ /**
+ * Minimal JSON object parser for the config file. Returns a flat Map of string keys to string
+ * values. Avoids pulling in Jackson/Gson as a dependency for this single use case.
+ */
+ @SuppressWarnings("unchecked")
+ private static Map parseJson(byte[] json) {
+ // Use the built-in scripting approach: parse as key-value pairs.
+ // The config JSON is simple: {"key": "value", ...} with string values only.
+ try {
+ var str = new String(json, StandardCharsets.UTF_8).trim();
+ if (!str.startsWith("{") || !str.endsWith("}")) return null;
+ str = str.substring(1, str.length() - 1);
+
+ var result = new java.util.LinkedHashMap();
+ int i = 0;
+ while (i < str.length()) {
+ // Skip whitespace and commas.
+ while (i < str.length()
+ && (str.charAt(i) == ' '
+ || str.charAt(i) == ','
+ || str.charAt(i) == '\n'
+ || str.charAt(i) == '\r'
+ || str.charAt(i) == '\t')) i++;
+ if (i >= str.length()) break;
+
+ // Parse key.
+ if (str.charAt(i) != '"') break;
+ int keyStart = ++i;
+ while (i < str.length() && str.charAt(i) != '"') {
+ if (str.charAt(i) == '\\') i++; // skip escaped char
+ i++;
+ }
+ var key = str.substring(keyStart, i);
+ i++; // closing quote
+
+ // Skip colon.
+ while (i < str.length() && (str.charAt(i) == ' ' || str.charAt(i) == ':')) i++;
+
+ // Parse value.
+ if (i >= str.length()) break;
+ if (str.charAt(i) == '"') {
+ int valStart = ++i;
+ var sb = new StringBuilder();
+ while (i < str.length() && str.charAt(i) != '"') {
+ if (str.charAt(i) == '\\' && i + 1 < str.length()) {
+ i++;
+ sb.append(
+ switch (str.charAt(i)) {
+ case 'n' -> '\n';
+ case 'r' -> '\r';
+ case 't' -> '\t';
+ case '\\' -> '\\';
+ case '"' -> '"';
+ default -> str.charAt(i);
+ });
+ } else {
+ sb.append(str.charAt(i));
+ }
+ i++;
+ }
+ result.put(key, sb.toString());
+ i++; // closing quote
+ } else {
+ // Non-string value (number, boolean, null) — read until comma/brace.
+ int valStart = i;
+ while (i < str.length() && str.charAt(i) != ',' && str.charAt(i) != '}') i++;
+ result.put(key, str.substring(valStart, i).trim());
+ }
+ }
+ return result;
+ } catch (Exception e) {
+ log.warn("JSON parse error: {}", e.getMessage());
+ return null;
+ }
+ }
+}
diff --git a/config/src/main/java/com/tcn/exile/config/ExileClientManager.java b/config/src/main/java/com/tcn/exile/config/ExileClientManager.java
new file mode 100644
index 0000000..177ade2
--- /dev/null
+++ b/config/src/main/java/com/tcn/exile/config/ExileClientManager.java
@@ -0,0 +1,230 @@
+package com.tcn.exile.config;
+
+import com.tcn.exile.ExileClient;
+import com.tcn.exile.ExileConfig;
+import com.tcn.exile.StreamStatus;
+import com.tcn.exile.handler.Plugin;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Manages the lifecycle of a single-tenant {@link ExileClient} driven by a config file.
+ *
+ *
+ */
+public final class ExileClientManager implements AutoCloseable {
+
+ private static final Logger log = LoggerFactory.getLogger(ExileClientManager.class);
+
+ private final String clientName;
+ private final String clientVersion;
+ private final int maxConcurrency;
+ private final Plugin plugin;
+ private final List watchDirs;
+ private final int certRotationHours;
+
+ private volatile ExileClient activeClient;
+ private volatile ExileConfig activeConfig;
+ private volatile String activeOrg;
+ private ConfigFileWatcher watcher;
+ private ScheduledExecutorService scheduler;
+
+ private ExileClientManager(Builder builder) {
+ this.clientName = builder.clientName;
+ this.clientVersion = builder.clientVersion;
+ this.maxConcurrency = builder.maxConcurrency;
+ this.plugin = builder.plugin;
+ this.watchDirs = builder.watchDirs;
+ this.certRotationHours = builder.certRotationHours;
+ }
+
+ /** Start watching the config file and managing the client lifecycle. */
+ public void start() throws IOException {
+ watcher =
+ watchDirs != null
+ ? ConfigFileWatcher.create(watchDirs, new WatcherListener())
+ : ConfigFileWatcher.create(new WatcherListener());
+ watcher.start();
+
+ scheduler =
+ Executors.newSingleThreadScheduledExecutor(
+ r -> {
+ var t = new Thread(r, "exile-cert-rotator");
+ t.setDaemon(true);
+ return t;
+ });
+ var rotator = new CertificateRotator(this);
+ scheduler.scheduleAtFixedRate(
+ () -> {
+ try {
+ rotator.checkAndRotate();
+ } catch (Exception e) {
+ log.warn("Certificate rotation check failed: {}", e.getMessage());
+ }
+ },
+ certRotationHours,
+ certRotationHours,
+ TimeUnit.HOURS);
+
+ log.info(
+ "ExileClientManager started (clientName={}, plugin={})", clientName, plugin.pluginName());
+ }
+
+ /** Returns the currently active client, or null if no config is loaded. */
+ public ExileClient client() {
+ return activeClient;
+ }
+
+ /** Returns a snapshot of the work stream status, or null if no client is active. */
+ public StreamStatus streamStatus() {
+ var c = activeClient;
+ return c != null ? c.streamStatus() : null;
+ }
+
+ ConfigFileWatcher configWatcher() {
+ return watcher;
+ }
+
+ public void stop() {
+ log.info("Stopping ExileClientManager");
+ destroyClient();
+ if (watcher != null) watcher.close();
+ if (scheduler != null) scheduler.shutdownNow();
+ }
+
+ @Override
+ public void close() {
+ stop();
+ }
+
+ private void createClient(ExileConfig config) {
+ log.info(
+ "Creating ExileClient (endpoint={}:{}, org={}, plugin={})",
+ config.apiHostname(),
+ config.apiPort(),
+ config.org(),
+ plugin.pluginName());
+ var newOrg = config.org();
+ if (activeOrg != null && !activeOrg.equals(newOrg)) {
+ log.info("Org changed from {} to {}, destroying old client", activeOrg, newOrg);
+ destroyClient();
+ }
+
+ destroyClient();
+
+ try {
+ activeClient =
+ ExileClient.builder()
+ .config(config)
+ .clientName(clientName)
+ .clientVersion(clientVersion)
+ .maxConcurrency(maxConcurrency)
+ .plugin(plugin)
+ .build();
+ activeClient.start();
+ activeConfig = config;
+ activeOrg = newOrg;
+ log.info("ExileClient started for org={}", newOrg);
+ } catch (Exception e) {
+ log.error("Failed to create ExileClient for org={}: {}", newOrg, e.getMessage(), e);
+ destroyClient();
+ }
+ }
+
+ private void destroyClient() {
+ var c = activeClient;
+ if (c != null) {
+ try {
+ c.close();
+ log.info("ExileClient closed for org={}", activeOrg);
+ } catch (Exception e) {
+ log.warn("Error closing ExileClient: {}", e.getMessage());
+ }
+ activeClient = null;
+ activeConfig = null;
+ }
+ }
+
+ private class WatcherListener implements ConfigFileWatcher.Listener {
+ @Override
+ public void onConfigChanged(ExileConfig config) {
+ createClient(config);
+ }
+
+ @Override
+ public void onConfigRemoved() {
+ log.info("Config removed, destroying client");
+ destroyClient();
+ activeOrg = null;
+ }
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ public static final class Builder {
+ private String clientName = "sati";
+ private String clientVersion = "unknown";
+ private int maxConcurrency = 100;
+ private Plugin plugin;
+ private List watchDirs;
+ private int certRotationHours = 1;
+
+ private Builder() {}
+
+ public Builder clientName(String clientName) {
+ this.clientName = Objects.requireNonNull(clientName);
+ return this;
+ }
+
+ public Builder clientVersion(String clientVersion) {
+ this.clientVersion = Objects.requireNonNull(clientVersion);
+ return this;
+ }
+
+ public Builder maxConcurrency(int maxConcurrency) {
+ this.maxConcurrency = maxConcurrency;
+ return this;
+ }
+
+ /** The plugin that handles jobs, events, and config validation. */
+ public Builder plugin(Plugin plugin) {
+ this.plugin = Objects.requireNonNull(plugin);
+ return this;
+ }
+
+ public Builder watchDirs(List watchDirs) {
+ this.watchDirs = watchDirs;
+ return this;
+ }
+
+ public Builder certRotationHours(int hours) {
+ this.certRotationHours = hours;
+ return this;
+ }
+
+ public ExileClientManager build() {
+ Objects.requireNonNull(plugin, "plugin is required");
+ return new ExileClientManager(this);
+ }
+ }
+}
diff --git a/config/src/main/java/com/tcn/exile/config/MultiTenantManager.java b/config/src/main/java/com/tcn/exile/config/MultiTenantManager.java
new file mode 100644
index 0000000..08962ab
--- /dev/null
+++ b/config/src/main/java/com/tcn/exile/config/MultiTenantManager.java
@@ -0,0 +1,213 @@
+package com.tcn.exile.config;
+
+import com.tcn.exile.ExileClient;
+import com.tcn.exile.ExileConfig;
+import com.tcn.exile.StreamStatus;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Manages multiple {@link ExileClient} instances for multi-tenant deployments.
+ *
+ *
Polls a tenant provider for the current set of tenants and their configs. Creates clients for
+ * new tenants, destroys clients for removed tenants, and updates clients when config changes.
+ *
+ *
+ */
+public final class MultiTenantManager implements AutoCloseable {
+
+ private static final Logger log = LoggerFactory.getLogger(MultiTenantManager.class);
+
+ private final Supplier> tenantProvider;
+ private final Function clientFactory;
+ private final long pollIntervalSeconds;
+
+ private final ConcurrentHashMap clients = new ConcurrentHashMap<>();
+ private final ConcurrentHashMap configs = new ConcurrentHashMap<>();
+ private volatile ScheduledExecutorService scheduler;
+
+ private MultiTenantManager(Builder builder) {
+ this.tenantProvider = builder.tenantProvider;
+ this.clientFactory = builder.clientFactory;
+ this.pollIntervalSeconds = builder.pollIntervalSeconds;
+ }
+
+ /** Start polling for tenants. */
+ public void start() {
+ scheduler =
+ Executors.newSingleThreadScheduledExecutor(
+ r -> {
+ var t = new Thread(r, "exile-tenant-poller");
+ t.setDaemon(true);
+ return t;
+ });
+ scheduler.scheduleAtFixedRate(this::reconcile, 0, pollIntervalSeconds, TimeUnit.SECONDS);
+ log.info("MultiTenantManager started (poll={}s)", pollIntervalSeconds);
+ }
+
+ /** Get the client for a specific tenant. Returns null if tenant not active. */
+ public ExileClient client(String tenantId) {
+ return clients.get(tenantId);
+ }
+
+ /** Returns all active tenant IDs. */
+ public Set tenantIds() {
+ return Collections.unmodifiableSet(clients.keySet());
+ }
+
+ /** Returns stream status for all tenants. */
+ public Map allStatuses() {
+ var result = new ConcurrentHashMap();
+ clients.forEach((id, client) -> result.put(id, client.streamStatus()));
+ return result;
+ }
+
+ /** Stop all tenants and the polling loop. */
+ public void stop() {
+ log.info("Stopping MultiTenantManager ({} tenants)", clients.size());
+ if (scheduler != null) scheduler.shutdownNow();
+ clients.keySet().forEach(this::destroyTenant);
+ }
+
+ @Override
+ public void close() {
+ stop();
+ }
+
+ private void reconcile() {
+ try {
+ var desired = tenantProvider.get();
+ if (desired == null) {
+ log.warn("Tenant provider returned null");
+ return;
+ }
+
+ // Remove tenants no longer in the desired set.
+ for (var existingId : clients.keySet()) {
+ if (!desired.containsKey(existingId)) {
+ log.info("Tenant {} removed, destroying client", existingId);
+ destroyTenant(existingId);
+ }
+ }
+
+ // Create or update tenants.
+ for (var entry : desired.entrySet()) {
+ var tenantId = entry.getKey();
+ var newConfig = entry.getValue();
+ var existingConfig = configs.get(tenantId);
+
+ if (existingConfig == null) {
+ // New tenant.
+ createTenant(tenantId, newConfig);
+ } else if (!existingConfig.org().equals(newConfig.org())) {
+ // Config changed (different org/certs).
+ log.info("Tenant {} config changed, recreating client", tenantId);
+ destroyTenant(tenantId);
+ createTenant(tenantId, newConfig);
+ }
+ }
+ } catch (Exception e) {
+ log.warn("Tenant reconciliation failed: {}", e.getMessage());
+ }
+ }
+
+ private void createTenant(String tenantId, ExileConfig config) {
+ try {
+ var client = clientFactory.apply(config);
+ client.start();
+ clients.put(tenantId, client);
+ configs.put(tenantId, config);
+ log.info("Created client for tenant {} (org={})", tenantId, config.org());
+ } catch (Exception e) {
+ log.error("Failed to create client for tenant {}: {}", tenantId, e.getMessage());
+ }
+ }
+
+ private void destroyTenant(String tenantId) {
+ var client = clients.remove(tenantId);
+ configs.remove(tenantId);
+ if (client != null) {
+ try {
+ client.close();
+ log.info("Destroyed client for tenant {}", tenantId);
+ } catch (Exception e) {
+ log.warn("Error destroying client for tenant {}: {}", tenantId, e.getMessage());
+ }
+ }
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ public static final class Builder {
+ private Supplier> tenantProvider;
+ private Function clientFactory;
+ private long pollIntervalSeconds = 30;
+
+ private Builder() {}
+
+ /**
+ * Required. Provides the current set of tenants and their configs. Called on each poll cycle.
+ * The map key is the tenant ID, value is the ExileConfig for that tenant.
+ */
+ public Builder tenantProvider(Supplier> tenantProvider) {
+ this.tenantProvider = Objects.requireNonNull(tenantProvider);
+ return this;
+ }
+
+ /**
+ * Required. Factory that creates an ExileClient for a given config. The factory should call
+ * {@code ExileClient.builder()...build()} but NOT call {@code start()} — the manager handles
+ * that.
+ */
+ public Builder clientFactory(Function clientFactory) {
+ this.clientFactory = Objects.requireNonNull(clientFactory);
+ return this;
+ }
+
+ /** How often to poll the tenant provider (seconds). Default: 30. */
+ public Builder pollIntervalSeconds(long seconds) {
+ this.pollIntervalSeconds = seconds;
+ return this;
+ }
+
+ public MultiTenantManager build() {
+ Objects.requireNonNull(tenantProvider, "tenantProvider required");
+ Objects.requireNonNull(clientFactory, "clientFactory required");
+ return new MultiTenantManager(this);
+ }
+ }
+}
diff --git a/config/src/test/java/com/tcn/exile/config/ConfigParserTest.java b/config/src/test/java/com/tcn/exile/config/ConfigParserTest.java
new file mode 100644
index 0000000..0fa367f
--- /dev/null
+++ b/config/src/test/java/com/tcn/exile/config/ConfigParserTest.java
@@ -0,0 +1,120 @@
+package com.tcn.exile.config;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import org.junit.jupiter.api.Test;
+
+class ConfigParserTest {
+
+ private static final String VALID_JSON =
+ """
+ {
+ "ca_certificate": "-----BEGIN CERTIFICATE-----\\nROOT\\n-----END CERTIFICATE-----",
+ "certificate": "-----BEGIN CERTIFICATE-----\\nPUBLIC\\n-----END CERTIFICATE-----",
+ "private_key": "-----BEGIN PRIVATE KEY-----\\nKEY\\n-----END PRIVATE KEY-----",
+ "api_endpoint": "gate.example.com:8443"
+ }
+ """;
+
+ @Test
+ void parsesBase64EncodedJson() {
+ var base64 = Base64.getEncoder().encode(VALID_JSON.getBytes(StandardCharsets.UTF_8));
+ var result = ConfigParser.parse(base64);
+ assertTrue(result.isPresent());
+ var config = result.get();
+ assertTrue(config.rootCert().contains("ROOT"));
+ assertTrue(config.publicCert().contains("PUBLIC"));
+ assertTrue(config.privateKey().contains("KEY"));
+ assertEquals("gate.example.com", config.apiHostname());
+ assertEquals(8443, config.apiPort());
+ }
+
+ @Test
+ void parsesRawJson() {
+ var raw = VALID_JSON.getBytes(StandardCharsets.UTF_8);
+ var result = ConfigParser.parse(raw);
+ assertTrue(result.isPresent());
+ assertEquals("gate.example.com", result.get().apiHostname());
+ }
+
+ @Test
+ void parsesJsonWithoutPort() {
+ var json =
+ """
+ {
+ "ca_certificate": "root",
+ "certificate": "pub",
+ "private_key": "key",
+ "api_endpoint": "gate.example.com"
+ }
+ """;
+ var result = ConfigParser.parse(json.getBytes(StandardCharsets.UTF_8));
+ assertTrue(result.isPresent());
+ assertEquals("gate.example.com", result.get().apiHostname());
+ assertEquals(443, result.get().apiPort());
+ }
+
+ @Test
+ void parsesJsonWithoutEndpoint() {
+ var json =
+ """
+ {
+ "ca_certificate": "root",
+ "certificate": "pub",
+ "private_key": "key"
+ }
+ """;
+ var result = ConfigParser.parse(json.getBytes(StandardCharsets.UTF_8));
+ // Should fail because apiHostname is required in ExileConfig
+ // but the JSON itself is valid
+ assertFalse(result.isPresent());
+ }
+
+ @Test
+ void rejectsMissingCertFields() {
+ var json =
+ """
+ {"api_endpoint": "gate.example.com:443"}
+ """;
+ var result = ConfigParser.parse(json.getBytes(StandardCharsets.UTF_8));
+ assertFalse(result.isPresent());
+ }
+
+ @Test
+ void rejectsGarbage() {
+ var result = ConfigParser.parse("not-json-or-base64".getBytes(StandardCharsets.UTF_8));
+ assertFalse(result.isPresent());
+ }
+
+ @Test
+ void rejectsEmptyInput() {
+ var result = ConfigParser.parse(new byte[0]);
+ assertFalse(result.isPresent());
+ }
+
+ @Test
+ void handlesBase64WithTrailingNewline() {
+ var base64 =
+ Base64.getEncoder().encodeToString(VALID_JSON.getBytes(StandardCharsets.UTF_8)) + "\n";
+ var result = ConfigParser.parse(base64.getBytes(StandardCharsets.UTF_8));
+ assertTrue(result.isPresent());
+ }
+
+ @Test
+ void handlesEscapedNewlinesInCerts() {
+ var json =
+ """
+ {
+ "ca_certificate": "line1\\nline2\\nline3",
+ "certificate": "pub",
+ "private_key": "key",
+ "api_endpoint": "host:443"
+ }
+ """;
+ var result = ConfigParser.parse(json.getBytes(StandardCharsets.UTF_8));
+ assertTrue(result.isPresent());
+ assertTrue(result.get().rootCert().contains("\n"));
+ }
+}
diff --git a/core/build.gradle b/core/build.gradle
index 66800ae..62eaaa1 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -1,91 +1,46 @@
plugins {
+ id("java-library")
id("com.github.johnrengelman.shadow")
- id("io.micronaut.library")
- id("io.micronaut.aot")
id("maven-publish")
id("jacoco")
}
-repositories {
- mavenLocal()
- mavenCentral()
-}
-
-dependencies {
- annotationProcessor("io.micronaut:micronaut-http-validation")
- annotationProcessor("io.micronaut.serde:micronaut-serde-processor")
- annotationProcessor("io.micronaut.validation:micronaut-validation-processor")
- runtimeOnly("io.micronaut:micronaut-http-client")
- runtimeOnly("io.micronaut:micronaut-http-server-netty")
- runtimeOnly("io.micronaut.validation:micronaut-validation")
-
- // Reactor for reactive streams
- implementation("io.projectreactor:reactor-core:3.5.12")
- api("jakarta.annotation:jakarta.annotation-api")
- api("jakarta.validation:jakarta.validation-api")
-
- runtimeOnly("ch.qos.logback:logback-classic")
-
- // uses exileapi v1.0.1 - NOTE: you must use api to propagate the proto files to the other projects
+dependencies {
+ // exileapi v3 pre-built stubs from buf.build BSR
api("build.buf.gen:tcn_exileapi_grpc_java:${exileapiGrpcVersion}")
+ api("build.buf.gen:tcn_exileapi_protocolbuffers_java:${exileapiProtobufVersion}")
- implementation("com.zaxxer:HikariCP:6.3.0")
-
- // gRPC client dependencies only (no server)
+ // gRPC — client only
+ api("io.grpc:grpc-api:${grpcVersion}")
api("io.grpc:grpc-protobuf:${grpcVersion}")
- api("io.grpc:grpc-services:${grpcVersion}") {
- exclude group: "io.grpc", module: "grpc-health-service"
- }
api("io.grpc:grpc-stub:${grpcVersion}")
- compileOnly("org.apache.tomcat:annotations-api:6.0.53")
- runtimeOnly("io.grpc:grpc-netty-shaded:${grpcVersion}")
- api("com.google.protobuf:protobuf-java-util:${protobufVersion}")
+ implementation("io.grpc:grpc-netty-shaded:${grpcVersion}")
- // Add SnakeYAML for YAML configuration support
- runtimeOnly("org.yaml:snakeyaml")
+ // protobuf runtime
+ api("com.google.protobuf:protobuf-java:${protobufVersion}")
- testRuntimeOnly("io.micronaut:micronaut-http-client")
+ // OpenTelemetry SDK — metrics, tracing, and custom exporter
+ implementation("io.opentelemetry:opentelemetry-api:1.46.0")
+ implementation("io.opentelemetry:opentelemetry-sdk:1.46.0")
+ implementation("io.opentelemetry:opentelemetry-sdk-metrics:1.46.0")
+ implementation("io.opentelemetry:opentelemetry-sdk-trace:1.46.0")
- api('io.micronaut.serde:micronaut-serde-api:2.12.1')
- implementation('com.google.protobuf:protobuf-java:4.28.3')
- api('io.micronaut:micronaut-context:4.7.14')
- api('io.micronaut:micronaut-core:4.7.14')
- api('com.fasterxml.jackson.core:jackson-annotations:2.17.2')
- api("build.buf.gen:tcn_exileapi_protocolbuffers_java:${exileapiProtobufVersion}")
- api("io.grpc:grpc-api:${grpcVersion}")
-}
+ // PKCS#1 → PKCS#8 key conversion for mTLS
+ implementation("org.bouncycastle:bcpkix-jdk18on:1.79")
-java {
- sourceCompatibility = JavaVersion.toVersion("21")
- targetCompatibility = JavaVersion.toVersion("21")
-}
+ // In-memory log buffer for listTenantLogs/setLogLevel
+ implementation(project(':logback-ext'))
-graalvmNative.toolchainDetection = false
+ // javax.annotation for @Generated in gRPC stubs
+ compileOnly("org.apache.tomcat:annotations-api:6.0.53")
-micronaut {
- runtime("netty")
- testRuntime("junit5")
- processing {
- incremental(true)
- annotations("com.tcn.exile.*")
- }
- aot {
- // Please review carefully the optimizations enabled below
- // Check https://micronaut-projects.github.io/micronaut-aot/latest/guide/ for more details
- optimizeServiceLoading = false
- convertYamlToJava = false
- precomputeOperations = true
- cacheEnvironment = true
- optimizeClassLoading = true
- deduceEnvironment = true
- optimizeNetty = true
- replaceLogbackXml = true
- }
+ // test
+ testImplementation("io.grpc:grpc-testing:${grpcVersion}")
+ testImplementation("io.grpc:grpc-inprocess:${grpcVersion}")
}
-// Configure JaCoCo for test coverage
jacoco {
toolVersion = "0.8.11"
}
@@ -95,23 +50,10 @@ jacocoTestReport {
xml.required = true
html.required = true
}
-
- afterEvaluate {
- classDirectories.setFrom(files(classDirectories.files.collect {
- fileTree(dir: it, exclude: [
- '**/*$Lambda$*/**',
- '**/*$$*/**',
- '**/*_Micronaut*/**',
- '**/micronaut/**'
- ])
- }))
- }
+ dependsOn test
}
test {
+ exclude '**/LiveBenchmark*'
finalizedBy jacocoTestReport
}
-
-jacocoTestReport {
- dependsOn test
-}
diff --git a/core/src/main/java/com/tcn/exile/ExileClient.java b/core/src/main/java/com/tcn/exile/ExileClient.java
new file mode 100644
index 0000000..bfa0b60
--- /dev/null
+++ b/core/src/main/java/com/tcn/exile/ExileClient.java
@@ -0,0 +1,309 @@
+package com.tcn.exile;
+
+import com.tcn.exile.handler.Plugin;
+import com.tcn.exile.internal.ChannelFactory;
+import com.tcn.exile.internal.GrpcLogShipper;
+import com.tcn.exile.internal.MetricsManager;
+import com.tcn.exile.internal.WorkStreamClient;
+import com.tcn.exile.memlogger.MemoryAppender;
+import com.tcn.exile.memlogger.MemoryAppenderInstance;
+import com.tcn.exile.service.*;
+import io.grpc.ManagedChannel;
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.api.trace.Span;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Main entry point for the Exile client library.
+ *
+ *
On {@link #start()}, only the config poller begins. The WorkStream does not open until:
+ *
+ *
+ *
The first successful config poll from the gate
+ *
The {@link Plugin#onConfig} returns {@code true}
+ *
+ */
+public final class ExileClient implements AutoCloseable {
+
+ private static final Logger log = LoggerFactory.getLogger(ExileClient.class);
+
+ private final ExileConfig config;
+ private final Plugin plugin;
+ private final WorkStreamClient workStream;
+ private final ManagedChannel serviceChannel;
+ private final ScheduledExecutorService configPoller;
+ private final Duration configPollInterval;
+
+ private final AgentService agentService;
+ private final CallService callService;
+ private final RecordingService recordingService;
+ private final ScrubListService scrubListService;
+ private final ConfigService configService;
+ private final JourneyService journeyService;
+ private final TelemetryService telemetryService;
+ private final String telemetryClientId;
+ private volatile MetricsManager metricsManager;
+
+ private volatile ConfigService.ClientConfiguration lastConfig;
+ private final AtomicBoolean pluginReady = new AtomicBoolean(false);
+ private final AtomicBoolean workStreamStarted = new AtomicBoolean(false);
+
+ private ExileClient(Builder builder) {
+ this.config = builder.config;
+ this.plugin = builder.plugin;
+ this.configPollInterval = builder.configPollInterval;
+
+ this.workStream =
+ new WorkStreamClient(
+ config,
+ plugin,
+ plugin,
+ builder.clientName,
+ builder.clientVersion,
+ builder.maxConcurrency,
+ builder.capabilities);
+
+ this.serviceChannel = ChannelFactory.create(config);
+ var services = ServiceFactory.create(serviceChannel);
+ this.agentService = services.agent();
+ this.callService = services.call();
+ this.recordingService = services.recording();
+ this.scrubListService = services.scrubList();
+ this.configService = services.config();
+ this.journeyService = services.journey();
+ this.telemetryService = services.telemetry();
+
+ // Telemetry client ID (stable across reconnects).
+ this.telemetryClientId =
+ builder.clientName + "-" + java.util.UUID.randomUUID().toString().substring(0, 8);
+
+ // Wire OTel trace context into log events so each LogRecord carries trace_id/span_id.
+ MemoryAppender.setTraceContextExtractor(
+ new MemoryAppender.TraceContextExtractor() {
+ @Override
+ public String traceId() {
+ var ctx = Span.current().getSpanContext();
+ return ctx.isValid() ? ctx.getTraceId() : null;
+ }
+
+ @Override
+ public String spanId() {
+ var ctx = Span.current().getSpanContext();
+ return ctx.isValid() ? ctx.getSpanId() : null;
+ }
+ });
+
+ // Structured log shipping starts immediately (doesn't need org_id).
+ var appender = MemoryAppenderInstance.getInstance();
+ if (appender != null) {
+ appender.enableLogShipper(new GrpcLogShipper(telemetryService, telemetryClientId));
+ }
+
+ // MetricsManager is created after first config poll (needs org_id + configName).
+
+ this.configPoller =
+ Executors.newSingleThreadScheduledExecutor(
+ r -> {
+ var t = new Thread(r, "exile-config-poller");
+ t.setDaemon(true);
+ return t;
+ });
+ }
+
+ /**
+ * Start the client. Only the config poller begins immediately. The WorkStream opens after the
+ * plugin accepts the first config via {@link Plugin#onConfig}.
+ */
+ public void start() {
+ log.info(
+ "Starting ExileClient for org={} (plugin={}, waiting for config)",
+ config.org(),
+ plugin.pluginName());
+
+ configPoller.scheduleAtFixedRate(
+ this::pollConfig, 0, configPollInterval.toSeconds(), TimeUnit.SECONDS);
+ }
+
+ private void pollConfig() {
+ try {
+ var newConfig = configService.getClientConfiguration();
+ if (newConfig == null) return;
+
+ boolean changed = lastConfig == null || !newConfig.equals(lastConfig);
+ lastConfig = newConfig;
+
+ if (changed) {
+ log.info(
+ "Config received from gate (org={}, configName={})",
+ newConfig.orgId(),
+ newConfig.configName());
+
+ boolean ready;
+ try {
+ ready = plugin.onConfig(newConfig);
+ } catch (Exception e) {
+ log.warn("Plugin {} rejected config: {}", plugin.pluginName(), e.getMessage());
+ pluginReady.set(false);
+ return;
+ }
+
+ if (!ready) {
+ log.warn("Plugin {} not ready — WorkStream will not start yet", plugin.pluginName());
+ pluginReady.set(false);
+ return;
+ }
+
+ pluginReady.set(true);
+ }
+
+ // Only start WorkStream + metrics once plugin has explicitly accepted a config.
+ if (pluginReady.get() && workStreamStarted.compareAndSet(false, true)) {
+ // Initialize MetricsManager now that we have org_id and certificate_name.
+ this.metricsManager =
+ new MetricsManager(
+ telemetryService,
+ telemetryClientId,
+ newConfig.orgId(),
+ config.certificateName(),
+ workStream::status);
+ workStream.setDurationRecorder(metricsManager::recordWorkDuration);
+ workStream.setMethodRecorder(metricsManager::recordMethodCall);
+ workStream.setReconnectRecorder(metricsManager::recordReconnectDuration);
+
+ log.info("Plugin {} ready, starting WorkStream", plugin.pluginName());
+ workStream.start();
+ }
+ } catch (Exception e) {
+ log.debug("Config poll failed ({}): {}", e.getClass().getSimpleName(), e.getMessage());
+ }
+ }
+
+ /** Returns the last polled config from the gate, or null if never polled. */
+ public ConfigService.ClientConfiguration lastPolledConfig() {
+ return lastConfig;
+ }
+
+ public StreamStatus streamStatus() {
+ return workStream.status();
+ }
+
+ public ExileConfig config() {
+ return config;
+ }
+
+ public Plugin plugin() {
+ return plugin;
+ }
+
+ public AgentService agents() {
+ return agentService;
+ }
+
+ public CallService calls() {
+ return callService;
+ }
+
+ public RecordingService recordings() {
+ return recordingService;
+ }
+
+ public ScrubListService scrubLists() {
+ return scrubListService;
+ }
+
+ public ConfigService config_() {
+ return configService;
+ }
+
+ public JourneyService journey() {
+ return journeyService;
+ }
+
+ /**
+ * The OTel Meter for registering custom metrics from plugins. Instruments created on this meter
+ * are exported alongside sati's built-in metrics to the gate TelemetryService. Returns null if
+ * the first config poll has not completed yet.
+ */
+ public Meter meter() {
+ var mm = metricsManager;
+ return mm != null ? mm.meter() : null;
+ }
+
+ @Override
+ public void close() {
+ log.info("Shutting down ExileClient");
+ configPoller.shutdownNow();
+ var appender = MemoryAppenderInstance.getInstance();
+ if (appender != null) {
+ appender.disableLogShipper();
+ }
+ var mm = metricsManager;
+ if (mm != null) mm.close();
+ workStream.close();
+ ChannelFactory.shutdown(serviceChannel);
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ public static final class Builder {
+ private ExileConfig config;
+ private Plugin plugin;
+ private String clientName = "sati";
+ private String clientVersion = "unknown";
+ private int maxConcurrency = 5;
+ private List capabilities = new ArrayList<>();
+ private Duration configPollInterval = Duration.ofSeconds(10);
+
+ private Builder() {}
+
+ public Builder config(ExileConfig config) {
+ this.config = Objects.requireNonNull(config);
+ return this;
+ }
+
+ /** The plugin that handles jobs, events, and config validation. */
+ public Builder plugin(Plugin plugin) {
+ this.plugin = Objects.requireNonNull(plugin);
+ return this;
+ }
+
+ public Builder clientName(String clientName) {
+ this.clientName = Objects.requireNonNull(clientName);
+ return this;
+ }
+
+ public Builder clientVersion(String clientVersion) {
+ this.clientVersion = Objects.requireNonNull(clientVersion);
+ return this;
+ }
+
+ public Builder maxConcurrency(int maxConcurrency) {
+ if (maxConcurrency < 1) throw new IllegalArgumentException("maxConcurrency must be >= 1");
+ this.maxConcurrency = maxConcurrency;
+ return this;
+ }
+
+ /** How often to poll the gate for config updates. Default: 10 seconds. */
+ public Builder configPollInterval(Duration interval) {
+ this.configPollInterval = Objects.requireNonNull(interval);
+ return this;
+ }
+
+ public ExileClient build() {
+ Objects.requireNonNull(config, "config is required");
+ Objects.requireNonNull(plugin, "plugin is required");
+ return new ExileClient(this);
+ }
+ }
+}
diff --git a/core/src/main/java/com/tcn/exile/ExileConfig.java b/core/src/main/java/com/tcn/exile/ExileConfig.java
new file mode 100644
index 0000000..5c10a65
--- /dev/null
+++ b/core/src/main/java/com/tcn/exile/ExileConfig.java
@@ -0,0 +1,143 @@
+package com.tcn.exile;
+
+import java.io.ByteArrayInputStream;
+import java.nio.charset.StandardCharsets;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+import java.util.Objects;
+
+/**
+ * Immutable configuration for connecting to the Exile gate server.
+ *
+ *
Holds mTLS credentials and server endpoint information. Built via {@link #builder()}.
+ */
+public final class ExileConfig {
+
+ private final String rootCert;
+ private final String publicCert;
+ private final String privateKey;
+ private final String apiHostname;
+ private final int apiPort;
+ private final String certificateName;
+
+ // Lazily derived from certificate.
+ private volatile String org;
+
+ private ExileConfig(Builder builder) {
+ this.rootCert = Objects.requireNonNull(builder.rootCert, "rootCert");
+ this.publicCert = Objects.requireNonNull(builder.publicCert, "publicCert");
+ this.privateKey = Objects.requireNonNull(builder.privateKey, "privateKey");
+ this.apiHostname = Objects.requireNonNull(builder.apiHostname, "apiHostname");
+ this.apiPort = builder.apiPort > 0 ? builder.apiPort : 443;
+ this.certificateName = builder.certificateName != null ? builder.certificateName : "";
+ }
+
+ public String rootCert() {
+ return rootCert;
+ }
+
+ public String publicCert() {
+ return publicCert;
+ }
+
+ public String privateKey() {
+ return privateKey;
+ }
+
+ public String apiHostname() {
+ return apiHostname;
+ }
+
+ public int apiPort() {
+ return apiPort;
+ }
+
+ /** The certificate name from the config file (may be empty). */
+ public String certificateName() {
+ return certificateName;
+ }
+
+ /** Extracts the organization name from the certificate CN field. Thread-safe. */
+ public String org() {
+ String result = org;
+ if (result == null) {
+ synchronized (this) {
+ result = org;
+ if (result == null) {
+ result = parseOrgFromCert();
+ org = result;
+ }
+ }
+ }
+ return result;
+ }
+
+ private String parseOrgFromCert() {
+ try {
+ CertificateFactory cf = CertificateFactory.getInstance("X.509");
+ X509Certificate cert =
+ (X509Certificate)
+ cf.generateCertificate(
+ new ByteArrayInputStream(publicCert.getBytes(StandardCharsets.UTF_8)));
+ String dn = cert.getSubjectX500Principal().getName();
+ for (String part : dn.split(",")) {
+ String trimmed = part.trim();
+ if (trimmed.startsWith("O=")) {
+ return trimmed.substring(2);
+ }
+ }
+ return "";
+ } catch (Exception e) {
+ throw new IllegalStateException("Failed to parse organization from certificate", e);
+ }
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ public static final class Builder {
+ private String rootCert;
+ private String publicCert;
+ private String privateKey;
+ private String apiHostname;
+ private int apiPort;
+ private String certificateName;
+
+ private Builder() {}
+
+ public Builder rootCert(String rootCert) {
+ this.rootCert = rootCert;
+ return this;
+ }
+
+ public Builder publicCert(String publicCert) {
+ this.publicCert = publicCert;
+ return this;
+ }
+
+ public Builder privateKey(String privateKey) {
+ this.privateKey = privateKey;
+ return this;
+ }
+
+ public Builder apiHostname(String apiHostname) {
+ this.apiHostname = apiHostname;
+ return this;
+ }
+
+ public Builder certificateName(String certificateName) {
+ this.certificateName = certificateName;
+ return this;
+ }
+
+ public Builder apiPort(int apiPort) {
+ this.apiPort = apiPort;
+ return this;
+ }
+
+ public ExileConfig build() {
+ return new ExileConfig(this);
+ }
+ }
+}
diff --git a/core/src/main/java/com/tcn/exile/StreamStatus.java b/core/src/main/java/com/tcn/exile/StreamStatus.java
new file mode 100644
index 0000000..dcf030f
--- /dev/null
+++ b/core/src/main/java/com/tcn/exile/StreamStatus.java
@@ -0,0 +1,49 @@
+package com.tcn.exile;
+
+import java.time.Instant;
+
+/**
+ * Snapshot of the bidirectional work stream's current state.
+ *
+ *
Obtain via {@link ExileClient#streamStatus()}.
+ */
+public record StreamStatus(
+ /** Current connection phase. */
+ Phase phase,
+ /** Server-assigned client ID (set after REGISTERED, null before). */
+ String clientId,
+ /** When the current stream connection was established (null if not connected). */
+ Instant connectedSince,
+ /** When the last disconnect occurred (null if never disconnected). */
+ Instant lastDisconnect,
+ /** Last error message (null if no error). */
+ String lastError,
+ /** Number of work items currently being processed. */
+ int inflight,
+ /** Total work items completed (results + acks) since start. */
+ long completedTotal,
+ /** Total work items that failed since start. */
+ long failedTotal,
+ /** Total stream reconnection attempts since start. */
+ long reconnectAttempts) {
+
+ public enum Phase {
+ /** Client created but start() not yet called. */
+ IDLE,
+ /** Connecting to the gate server. */
+ CONNECTING,
+ /** Stream open, Register sent, waiting for Registered response. */
+ REGISTERING,
+ /** Registered and actively pulling/processing work. */
+ ACTIVE,
+ /** Stream disconnected, waiting to reconnect (backoff). */
+ RECONNECTING,
+ /** Client has been closed. */
+ CLOSED
+ }
+
+ /** True if the stream is connected and processing work. */
+ public boolean isHealthy() {
+ return phase == Phase.ACTIVE;
+ }
+}
diff --git a/core/src/main/java/com/tcn/exile/config/Config.java b/core/src/main/java/com/tcn/exile/config/Config.java
deleted file mode 100644
index 8d27bdb..0000000
--- a/core/src/main/java/com/tcn/exile/config/Config.java
+++ /dev/null
@@ -1,483 +0,0 @@
-/*
- * (C) 2017-2024 TCN Inc. All rights reserved.
- *
- * Licensed 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
- *
- * https://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.
- *
- */
-package com.tcn.exile.config;
-
-import com.tcn.exile.gateclients.UnconfiguredException;
-import io.micronaut.core.type.Argument;
-import io.micronaut.serde.ObjectMapper;
-import io.micronaut.serde.annotation.Serdeable;
-import jakarta.validation.constraints.NotEmpty;
-import jakarta.validation.constraints.NotNull;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.security.cert.CertificateException;
-import java.security.cert.CertificateFactory;
-import java.security.cert.X509Certificate;
-import java.util.*;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/** Concrete implementation of ConfigInterface that stores configuration data. */
-@Serdeable
-public class Config {
- private static final List fieldNames =
- List.of(
- "ca_certificate",
- "certificate",
- "private_key",
- "fingerprint_sha256",
- "fingerprint_sha256_string",
- "api_endpoint",
- "certificate_name",
- "certificate_description");
- private static final Logger log = LoggerFactory.getLogger(Config.class);
-
- private boolean unconfigured;
- private String rootCert;
- private String publicCert;
- private String privateKey;
- private String fingerprintSha256;
- private String fingerprintSha256String;
- private String apiEndpoint;
- private String certificateName;
- private String certificateDescription;
- private String org = null;
-
- /** Default constructor - initializes as unconfigured. */
- public Config() {
- this.unconfigured = true;
- }
-
- /**
- * Copy constructor
- *
- * @param source The source config to copy from
- */
- public Config(Config source) {
- if (source != null) {
- this.unconfigured = source.isUnconfigured();
- this.rootCert = source.getRootCert();
- this.publicCert = source.getPublicCert();
- this.privateKey = source.getPrivateKey();
- this.fingerprintSha256 = source.getFingerprintSha256();
- this.fingerprintSha256String = source.getFingerprintSha256String();
- this.apiEndpoint = source.getApiEndpoint();
- this.certificateName = source.getCertificateName();
- this.certificateDescription = source.getCertificateDescription();
- }
- }
-
- public static Optional of(@NotNull byte[] data, @NotNull ObjectMapper objectMapper) {
- try {
- var map =
- objectMapper.readValue(
- Base64.getDecoder().decode(data), Argument.mapOf(String.class, String.class));
- if (!map.keySet().containsAll(fieldNames)) {
- log.error("Invalid certificate data format");
- return Optional.empty();
- }
- var ret =
- Optional.of(
- Config.builder()
- .rootCert(map.get("ca_certificate"))
- .publicCert(map.get("certificate"))
- .privateKey(map.get("private_key"))
- .fingerprintSha256(map.get("fingerprint_sha256"))
- .fingerprintSha256String(map.get("fingerprint_sha256_string"))
- .apiEndpoint(map.get("api_endpoint"))
- .certificateName(map.get("certificate_name"))
- .certificateDescription(map.get("certificate_description"))
- .build());
- if (ret.get().getOrg() == null) {
- log.error("Parsing certificate failed");
- return Optional.empty();
- }
- return ret;
- } catch (IOException e) {
- log.debug("Parsing error", e);
- return Optional.empty();
- }
- }
-
- /**
- * Constructor that takes a base64 encoded JSON string and parses it.
- *
- * @param base64EncodedJson The base64 encoded JSON string to parse
- * @param objectMapper The ObjectMapper to use for JSON deserialization
- * @throws UnconfiguredException If parsing fails
- */
- public Config(String base64EncodedJson, ObjectMapper objectMapper) throws UnconfiguredException {
- if (base64EncodedJson == null || base64EncodedJson.isEmpty()) {
- throw new UnconfiguredException("Base64 encoded JSON string cannot be null or empty");
- }
-
- try {
- byte[] jsonBytes = Base64.getDecoder().decode(base64EncodedJson);
- @SuppressWarnings("unchecked") // Suppress warning for Map cast
- Map jsonMap = objectMapper.readValue(jsonBytes, Map.class);
-
- this.rootCert = jsonMap.get("ca_certificate");
- this.publicCert = jsonMap.get("certificate");
- this.privateKey = jsonMap.get("private_key");
- this.fingerprintSha256 = jsonMap.get("fingerprint_sha256");
- this.fingerprintSha256String = jsonMap.get("fingerprint_sha256_string");
- this.apiEndpoint = jsonMap.get("api_endpoint");
- this.certificateName = jsonMap.get("certificate_name");
- this.certificateDescription = jsonMap.get("certificate_description");
- this.unconfigured = false;
-
- log.debug("Parsed base64 encoded JSON successfully");
- } catch (IOException e) {
- throw new UnconfiguredException("Failed to parse JSON", e);
- } catch (IllegalArgumentException e) {
- throw new UnconfiguredException("Invalid base64 string", e);
- }
- }
-
- /**
- * Private constructor for the Builder pattern.
- *
- * @param builder The builder instance to initialize from.
- */
- private Config(Builder builder) {
- this.unconfigured = builder.unconfigured;
- this.rootCert = builder.rootCert;
- this.publicCert = builder.publicCert;
- this.privateKey = builder.privateKey;
- this.fingerprintSha256 = builder.fingerprintSha256;
- this.fingerprintSha256String = builder.fingerprintSha256String;
- this.apiEndpoint = builder.apiEndpoint;
- this.certificateName = builder.certificateName;
- this.certificateDescription = builder.certificateDescription;
- }
-
- /**
- * Static factory method to create a Config from a base64 encoded JSON string.
- *
- * @param base64EncodedJson The base64 encoded JSON string to parse
- * @param objectMapper The ObjectMapper to use for JSON deserialization
- * @return A new Config instance
- * @throws UnconfiguredException If parsing fails
- */
- public static Config fromBase64Json(String base64EncodedJson, ObjectMapper objectMapper)
- throws UnconfiguredException {
- return new Config(base64EncodedJson, objectMapper);
- }
-
- /**
- * Static factory method to get a new Builder instance.
- *
- * @return A new Builder instance.
- */
- public static Builder builder() {
- return new Builder();
- }
-
- // --- Getters ---
-
- public String getCertificateDescription() {
- return certificateDescription;
- }
-
- public String getCertificateName() {
- return certificateName;
- }
-
- public String getApiEndpoint() {
- return apiEndpoint;
- }
-
- public String getFingerprintSha256() {
- return fingerprintSha256;
- }
-
- public String getFingerprintSha256String() {
- return fingerprintSha256String;
- }
-
- public boolean isUnconfigured() {
- return unconfigured;
- }
-
- public String getRootCert() {
- return rootCert;
- }
-
- public String getPublicCert() {
- return publicCert;
- }
-
- public String getPrivateKey() {
- return privateKey;
- }
-
- // --- Setters (Potentially make these package-private or remove if Builder is preferred) ---
- // Note: Setters are kept public for now to maintain compatibility with ConfigEvent.Builder and
- // direct usage.
- // Consider changing visibility if strict immutability via Builder is desired.
-
- public void setCertificateDescription(String certificateDescription) {
- this.certificateDescription = certificateDescription;
- }
-
- public void setCertificateName(String certificateName) {
- this.certificateName = certificateName;
- }
-
- public void setApiEndpoint(String apiEndpoint) {
- this.apiEndpoint = apiEndpoint;
- }
-
- public void setFingerprintSha256(String fingerprintSha256) {
- this.fingerprintSha256 = fingerprintSha256;
- }
-
- public void setFingerprintSha256String(String fingerprintSha256String) {
- this.fingerprintSha256String = fingerprintSha256String;
- }
-
- public void setUnconfigured(boolean unconfigured) {
- this.unconfigured = unconfigured;
- }
-
- public void setRootCert(String rootCert) {
- this.rootCert = rootCert;
- }
-
- public void setPublicCert(String publicCert) {
- this.publicCert = publicCert;
- }
-
- public void setPrivateKey(String privateKey) {
- this.privateKey = privateKey;
- }
-
- // --- Derived Data Methods ---
-
- public String getOrg() {
- if (this.org != null) {
- return this.org;
- }
- try {
- if (publicCert == null || publicCert.isBlank()) {
- return null;
- }
- CertificateFactory cf = CertificateFactory.getInstance("X.509");
- ByteArrayInputStream bais = new ByteArrayInputStream(publicCert.getBytes());
- X509Certificate cert = (X509Certificate) cf.generateCertificate(bais);
- String dn = cert.getSubjectX500Principal().getName();
- log.debug("Certificate Subject: " + dn);
-
- // Extract CN from DN
- for (String part : dn.split(",")) {
- if (part.trim().startsWith("O=")) {
- this.org = part.substring(2).trim();
- return this.org;
- }
- }
- return null;
- } catch (CertificateException e) {
- log.error("Error parsing certificate for getOrg: {}", e.getMessage());
- return null;
- } catch (Exception e) {
- log.error("Unexpected error in getOrg", e);
- return null;
- }
- }
-
- public String getApiHostname() throws UnconfiguredException {
- if (apiEndpoint == null || apiEndpoint.isBlank()) {
- throw new UnconfiguredException("API endpoint is not set");
- }
- try {
- return new URL(apiEndpoint).getHost();
- } catch (MalformedURLException e) {
- throw new UnconfiguredException("Invalid API endpoint URL: " + apiEndpoint, e);
- }
- }
-
- public int getApiPort() throws UnconfiguredException {
- if (apiEndpoint == null || apiEndpoint.isBlank()) {
- throw new UnconfiguredException("API endpoint is not set");
- }
- try {
- var url = new URL(apiEndpoint);
- if (url.getPort() == -1) {
- // Use default HTTPS port if not specified
- return 443;
- }
- return url.getPort();
- } catch (MalformedURLException e) {
- throw new UnconfiguredException("Invalid API endpoint URL: " + apiEndpoint, e);
- }
- }
-
- public Date getExpirationDate() {
- var certStr = this.getPublicCert();
- if (certStr == null || certStr.isBlank()) {
- return null;
- }
- try {
- CertificateFactory cf = CertificateFactory.getInstance("X.509");
- X509Certificate myCert =
- (X509Certificate) cf.generateCertificate(new ByteArrayInputStream(certStr.getBytes()));
- return myCert.getNotAfter();
- } catch (CertificateException e) {
- log.error("Error parsing certificate for expiration date: {}", e.getMessage());
- } catch (Exception e) {
- log.error("Unexpected error getting expiration date", e);
- }
- return null;
- }
-
- // --- Object Methods ---
-
- @Override
- public boolean equals(Object o) {
- if (this == o) return true;
- if (o == null || !(o instanceof Config)) return false;
-
- Config that = (Config) o;
-
- // Consider adding more fields for a more robust equality check if needed
- if (unconfigured != that.isUnconfigured()) return false;
- if (!Objects.equals(apiEndpoint, that.getApiEndpoint())) return false;
- if (!Objects.equals(getOrg(), that.getOrg())) return false; // Derived, might be slow
- return Objects.equals(publicCert, that.getPublicCert());
- }
-
- @Override
- public int hashCode() {
- // Consider adding more fields for a more robust hash code if needed
- return Objects.hash(unconfigured, apiEndpoint, getOrg(), publicCert);
- }
-
- @Override
- public String toString() {
- return "Config{"
- + "unconfigured="
- + unconfigured
- + ", apiEndpoint='"
- + apiEndpoint
- + '\''
- + ", certificateName='"
- + certificateName
- + '\''
- + ", org='"
- + getOrg()
- + "',..."
- + // Be mindful of potential null from getOrg()
- '}';
- }
-
- // --- Builder Class ---
-
- public static class Builder {
- private boolean unconfigured = true; // Default to unconfigured
- private String rootCert;
- private boolean rootCertSet = false;
- private String publicCert;
- private boolean publicCertSet = false;
- private String privateKey;
- private boolean privateKeySet = false;
- private String fingerprintSha256;
- private boolean fingerprintSha256Set = false;
- private String fingerprintSha256String;
- private boolean fingerprintSha256StringSet = false;
- private String apiEndpoint;
- private boolean apiEndpointSet = false;
- private String certificateName;
- private boolean certificateNameSet = false;
- private String certificateDescription;
- private boolean certificateDescriptionSet = false;
-
- public Builder rootCert(@NotEmpty String rootCert) {
- this.rootCert = rootCert;
- this.rootCertSet = true;
- return this;
- }
-
- public Builder publicCert(@NotEmpty String publicCert) {
- this.publicCert = publicCert;
- this.publicCertSet = true;
- return this;
- }
-
- public Builder privateKey(@NotEmpty String privateKey) {
- this.privateKey = privateKey;
- this.privateKeySet = true;
- return this;
- }
-
- public Builder fingerprintSha256(@NotEmpty String fingerprintSha256) {
- this.fingerprintSha256 = fingerprintSha256;
- this.fingerprintSha256Set = true;
- return this;
- }
-
- public Builder fingerprintSha256String(@NotEmpty String fingerprintSha256String) {
- this.fingerprintSha256String = fingerprintSha256String;
- this.fingerprintSha256Set = true;
- return this;
- }
-
- public Builder apiEndpoint(@NotEmpty String apiEndpoint) {
- this.apiEndpoint = apiEndpoint;
- this.apiEndpointSet = true;
- return this;
- }
-
- public Builder certificateName(@NotEmpty String certificateName) {
- this.certificateName = certificateName;
- this.certificateNameSet = true;
- return this;
- }
-
- public Builder certificateDescription(String certificateDescription) {
- this.certificateDescription = certificateDescription; // Can be null or empty
- this.certificateDescriptionSet = true;
- return this;
- }
-
- /**
- * Builds the Config object. It automatically sets unconfigured to false if essential fields
- * (e.g., apiEndpoint, publicCert) are set. Add more validation here if needed.
- *
- * @return A new Config instance.
- */
- public Config build() {
- this.unconfigured =
- !(this.rootCertSet
- && this.publicCertSet
- && this.privateKeySet
- && this.fingerprintSha256Set
- && this.fingerprintSha256StringSet
- && this.apiEndpointSet
- && this.certificateNameSet
- && this.certificateDescriptionSet);
-
- // Automatically mark as configured if key fields are provided
- if (this.unconfigured && apiEndpoint != null && publicCert != null) {
- log.debug("Builder automatically marking config as configured based on provided fields.");
- this.unconfigured = false;
- }
- return new Config(this);
- }
- }
-}
diff --git a/core/src/main/java/com/tcn/exile/config/DiagnosticsService.java b/core/src/main/java/com/tcn/exile/config/DiagnosticsService.java
deleted file mode 100644
index 2f6b7a2..0000000
--- a/core/src/main/java/com/tcn/exile/config/DiagnosticsService.java
+++ /dev/null
@@ -1,1652 +0,0 @@
-/*
- * (C) 2017-2025 TCN Inc. All rights reserved.
- *
- * Licensed 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
- *
- * https://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.
- *
- */
-package com.tcn.exile.config;
-
-import build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.DiagnosticsResult;
-import build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.DiagnosticsResult.*;
-import ch.qos.logback.classic.LoggerContext;
-import com.google.protobuf.Timestamp;
-import com.tcn.exile.plugin.PluginInterface;
-import io.micronaut.context.ApplicationContext;
-import jakarta.inject.Singleton;
-import java.io.File;
-import java.io.IOException;
-import java.lang.management.*;
-import java.lang.reflect.Method;
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.time.Instant;
-import java.util.*;
-import java.util.Base64;
-import java.util.regex.Pattern;
-import javax.management.MBeanServer;
-import javax.management.ObjectName;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-@Singleton
-public class DiagnosticsService {
- private static final Logger log = LoggerFactory.getLogger(DiagnosticsService.class);
-
- private static final Pattern DOCKER_PATTERN =
- Pattern.compile(".*docker.*", Pattern.CASE_INSENSITIVE);
- private static final Pattern KUBERNETES_PATTERN =
- Pattern.compile(".*k8s.*|.*kube.*", Pattern.CASE_INSENSITIVE);
-
- private final ApplicationContext applicationContext;
-
- public DiagnosticsService(ApplicationContext applicationContext) {
- this.applicationContext = applicationContext;
- }
-
- // Helper class to hold log collection results
- private static class LogCollectionResult {
- final List logs;
- final boolean success;
- final String errorMessage;
-
- LogCollectionResult(List logs, boolean success, String errorMessage) {
- this.logs = logs != null ? logs : new ArrayList<>();
- this.success = success;
- this.errorMessage = errorMessage;
- }
-
- static LogCollectionResult success(List logs) {
- return new LogCollectionResult(logs, true, null);
- }
-
- static LogCollectionResult failure(String errorMessage) {
- return new LogCollectionResult(null, false, errorMessage);
- }
- }
-
- public DiagnosticsResult collectSystemDiagnostics() {
- log.info("Collecting comprehensive system diagnostics...");
-
- try {
- Instant now = Instant.now();
- Timestamp timestamp =
- Timestamp.newBuilder().setSeconds(now.getEpochSecond()).setNanos(now.getNano()).build();
-
- // Collect Hikari metrics, config details, and event stream stats
- List hikariPoolMetrics = collectHikariMetrics();
- ConfigDetails configDetails = collectConfigDetails();
- EventStreamStats eventStreamStats = collectEventStreamStats();
-
- return DiagnosticsResult.newBuilder()
- .setTimestamp(timestamp)
- .setHostname(getHostname())
- .setOperatingSystem(collectOperatingSystemInfo())
- .setJavaRuntime(collectJavaRuntimeInfo())
- .setHardware(collectHardwareInfo())
- .setMemory(collectMemoryInfo())
- .addAllStorage(collectStorageInfo())
- .setContainer(collectContainerInfo())
- .setEnvironmentVariables(collectEnvironmentVariables())
- .setSystemProperties(collectSystemProperties())
- .addAllHikariPoolMetrics(hikariPoolMetrics)
- .setConfigDetails(configDetails)
- .setEventStreamStats(eventStreamStats)
- .build();
- } catch (Exception e) {
- log.error("Error collecting system diagnostics", e);
- throw new RuntimeException("Failed to collect system diagnostics", e);
- }
- }
-
- /**
- * Collects tenant logs and returns them in protobuf format for plugin responses. This method
- * handles time range filtering and log level detection.
- *
- * @param listTenantLogsRequest The request containing optional time range filtering
- * @return ListTenantLogsResult in protobuf format ready for submission to gate
- */
- public build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult
- collectTenantLogs(
- build.buf.gen.tcnapi.exile.gate.v2.StreamJobsResponse.ListTenantLogsRequest
- listTenantLogsRequest) {
- log.debug("Collecting tenant logs from memory appender...");
-
- long startTime = System.currentTimeMillis();
-
- try {
- // Extract time range from request if provided
- Long startTimeMs = null;
- Long endTimeMs = null;
- if (listTenantLogsRequest.hasTimeRange()) {
- // Use the exact same timestamp conversion logic that was working before
- startTimeMs =
- listTenantLogsRequest.getTimeRange().getStartTime().getSeconds() * 1000
- + listTenantLogsRequest.getTimeRange().getStartTime().getNanos() / 1000000;
- endTimeMs =
- listTenantLogsRequest.getTimeRange().getEndTime().getSeconds() * 1000
- + listTenantLogsRequest.getTimeRange().getEndTime().getNanos() / 1000000;
- log.debug(
- "Filtering logs with time range: {} to {} (timestamps: {} to {})",
- listTenantLogsRequest.getTimeRange().getStartTime(),
- listTenantLogsRequest.getTimeRange().getEndTime(),
- startTimeMs,
- endTimeMs);
- }
-
- // Collect logs using common method
- LogCollectionResult result = collectLogsFromMemoryAppender(startTimeMs, endTimeMs);
-
- // Create protobuf result
- build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult.Builder
- resultBuilder =
- build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult
- .newBuilder();
-
- if (result.success && !result.logs.isEmpty()) {
- // Create a single log group with all logs
- build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult.LogGroup
- .Builder
- logGroupBuilder =
- build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult
- .LogGroup.newBuilder()
- .setName("logGroups/memory-logs")
- .addAllLogs(result.logs);
-
- // Set time range
- if (listTenantLogsRequest.hasTimeRange()) {
- logGroupBuilder.setTimeRange(listTenantLogsRequest.getTimeRange());
- } else {
- // Fallback to current time
- long now = System.currentTimeMillis();
- logGroupBuilder.setTimeRange(
- build.buf.gen.tcnapi.exile.gate.v2.TimeRange.newBuilder()
- .setStartTime(createTimestamp(now))
- .setEndTime(createTimestamp(now))
- .build());
- }
-
- // Detect log levels from the actual logs
- Map<
- String,
- build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult
- .LogGroup.LogLevel>
- detectedLevels = detectLogLevelsByLogger();
-
- // If no loggers were detected, provide a default
- if (detectedLevels.isEmpty()) {
- detectedLevels.put(
- "memory",
- build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult
- .LogGroup.LogLevel.INFO);
- }
-
- detectedLevels.forEach(logGroupBuilder::putLogLevels);
-
- resultBuilder.addLogGroups(logGroupBuilder.build());
- }
-
- long duration = System.currentTimeMillis() - startTime;
- log.debug("Successfully collected tenant logs in {}ms", duration);
-
- return resultBuilder.build();
- } catch (Exception e) {
- log.error("Error collecting tenant logs: {}", e.getMessage(), e);
- return build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult
- .newBuilder()
- .build();
- }
- }
-
- /**
- * Collects tenant logs from the MemoryAppender and returns them as a serializable result. Uses
- * reflection to access MemoryAppender classes since they're in a different module.
- *
- * @return TenantLogsResult containing the collected logs
- */
- public com.tcn.exile.models.TenantLogsResult collectSerdeableTenantLogs() {
- return collectSerdeableTenantLogs(null, null);
- }
-
- /**
- * Collects tenant logs from the MemoryAppender within a specific time range.
- *
- * @param startTimeMs Start time in milliseconds since epoch, or null for no start limit
- * @param endTimeMs End time in milliseconds since epoch, or null for no end limit
- * @return TenantLogsResult containing the collected logs
- */
- public com.tcn.exile.models.TenantLogsResult collectSerdeableTenantLogs(
- Long startTimeMs, Long endTimeMs) {
- log.debug("Collecting tenant logs from memory appender...");
-
- try {
- // Collect logs using common method
- LogCollectionResult result = collectLogsFromMemoryAppender(startTimeMs, endTimeMs);
-
- // Create the result object
- com.tcn.exile.models.TenantLogsResult tenantLogsResult =
- new com.tcn.exile.models.TenantLogsResult();
- List logGroups = new ArrayList<>();
-
- if (result.success && !result.logs.isEmpty()) {
- // Create a single log group with all logs
- com.tcn.exile.models.TenantLogsResult.LogGroup logGroup =
- new com.tcn.exile.models.TenantLogsResult.LogGroup();
- logGroup.setName("logGroups/memory-logs");
- logGroup.setLogs(result.logs);
-
- // Set time range based on actual parameters used for filtering
- com.tcn.exile.models.TenantLogsResult.LogGroup.TimeRange timeRange =
- new com.tcn.exile.models.TenantLogsResult.LogGroup.TimeRange();
-
- if (startTimeMs != null && endTimeMs != null) {
- // Use the actual time parameters that were used for filtering
- timeRange.setStartTime(java.time.Instant.ofEpochMilli(startTimeMs));
- timeRange.setEndTime(java.time.Instant.ofEpochMilli(endTimeMs));
- } else {
- java.time.Instant now = java.time.Instant.now();
- java.time.Instant oneHourAgo = now.minusSeconds(600);
- timeRange.setStartTime(oneHourAgo);
- timeRange.setEndTime(now);
- }
- logGroup.setTimeRange(timeRange);
-
- // Detect log levels by logger name from the actual logs
- Map logLevels =
- detectSerializableLogLevelsByLogger();
-
- logGroup.setLogLevels(logLevels);
-
- logGroups.add(logGroup);
- log.info("Created log group with {} log entries", result.logs.size());
- } else {
- log.info("No logs found in memory appender");
- }
-
- tenantLogsResult.setLogGroups(logGroups);
- tenantLogsResult.setNextPageToken(""); // No pagination for now
-
- return tenantLogsResult;
- } catch (Exception e) {
- log.error("Error collecting tenant logs", e);
- // Return empty result on error
- com.tcn.exile.models.TenantLogsResult result = new com.tcn.exile.models.TenantLogsResult();
- result.setLogGroups(new ArrayList<>());
- result.setNextPageToken("");
- return result;
- }
- }
-
- /**
- * Detects log levels by logger name from the LoggerContext system configuration. This method
- * retrieves actual configured log levels rather than parsing from log output.
- *
- * @return Map of logger names to their configured log levels
- */
- private Map<
- String,
- build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult.LogGroup
- .LogLevel>
- detectLogLevelsByLogger() {
- Map<
- String,
- build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult.LogGroup
- .LogLevel>
- result = new HashMap<>();
-
- try {
- // Get the logback logger context
- LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
-
- // Get all configured loggers
- List loggers = loggerContext.getLoggerList();
-
- for (ch.qos.logback.classic.Logger logger : loggers) {
- String loggerName = logger.getName();
- ch.qos.logback.classic.Level level = logger.getLevel();
-
- // Skip loggers without explicit levels (they inherit from parent)
- if (level != null) {
- build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult.LogGroup
- .LogLevel
- protobufLevel = convertLogbackLevelToProtobuf(level);
- result.put(loggerName, protobufLevel);
- } else {
- // For loggers without explicit levels, check effective level
- ch.qos.logback.classic.Level effectiveLevel = logger.getEffectiveLevel();
- if (effectiveLevel != null) {
- build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult.LogGroup
- .LogLevel
- protobufLevel = convertLogbackLevelToProtobuf(effectiveLevel);
- result.put(loggerName + " (inherited)", protobufLevel);
- }
- }
- }
-
- // Always include root logger information
- ch.qos.logback.classic.Logger rootLogger =
- loggerContext.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME);
- if (rootLogger != null) {
- ch.qos.logback.classic.Level rootLevel = rootLogger.getLevel();
- if (rootLevel != null) {
- build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult.LogGroup
- .LogLevel
- protobufLevel = convertLogbackLevelToProtobuf(rootLevel);
- result.put("ROOT", protobufLevel);
- }
- }
-
- } catch (Exception e) {
- log.warn("Error detecting log levels from LoggerContext: {}", e.getMessage(), e);
- // Fallback to default
- result.put(
- "system.default",
- build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult.LogGroup
- .LogLevel.INFO);
- }
-
- return result;
- }
-
- /**
- * Detects log levels by logger name from the LoggerContext system configuration for serializable
- * results. This method retrieves actual configured log levels rather than parsing from log
- * output.
- *
- * @return Map of logger names to their configured log levels
- */
- private Map
- detectSerializableLogLevelsByLogger() {
- Map result = new HashMap<>();
-
- try {
- // Get the logback logger context
- LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
-
- // Get all configured loggers
- List loggers = loggerContext.getLoggerList();
-
- for (ch.qos.logback.classic.Logger logger : loggers) {
- String loggerName = logger.getName();
- ch.qos.logback.classic.Level level = logger.getLevel();
-
- // Skip loggers without explicit levels (they inherit from parent)
- if (level != null) {
- com.tcn.exile.models.TenantLogsResult.LogGroup.LogLevel serializableLevel =
- convertLogbackLevelToSerializable(level);
- result.put(loggerName, serializableLevel);
- } else {
- // For loggers without explicit levels, check effective level
- ch.qos.logback.classic.Level effectiveLevel = logger.getEffectiveLevel();
- if (effectiveLevel != null) {
- com.tcn.exile.models.TenantLogsResult.LogGroup.LogLevel serializableLevel =
- convertLogbackLevelToSerializable(effectiveLevel);
- result.put(loggerName + " (inherited)", serializableLevel);
- }
- }
- }
-
- // Always include root logger information
- ch.qos.logback.classic.Logger rootLogger =
- loggerContext.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME);
- if (rootLogger != null) {
- ch.qos.logback.classic.Level rootLevel = rootLogger.getLevel();
- if (rootLevel != null) {
- com.tcn.exile.models.TenantLogsResult.LogGroup.LogLevel serializableLevel =
- convertLogbackLevelToSerializable(rootLevel);
- result.put("ROOT", serializableLevel);
- }
- }
-
- } catch (Exception e) {
- log.warn("Error detecting log levels from LoggerContext: {}", e.getMessage(), e);
- // Fallback to default
- result.put("system.default", com.tcn.exile.models.TenantLogsResult.LogGroup.LogLevel.INFO);
- }
-
- return result;
- }
-
- /** Converts logback Level to protobuf LogLevel enum. */
- private build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult.LogGroup
- .LogLevel
- convertLogbackLevelToProtobuf(ch.qos.logback.classic.Level logbackLevel) {
- switch (logbackLevel.toInt()) {
- case ch.qos.logback.classic.Level.TRACE_INT:
- case ch.qos.logback.classic.Level.DEBUG_INT:
- return build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult
- .LogGroup.LogLevel.DEBUG;
- case ch.qos.logback.classic.Level.INFO_INT:
- return build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult
- .LogGroup.LogLevel.INFO;
- case ch.qos.logback.classic.Level.WARN_INT:
- return build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult
- .LogGroup.LogLevel.WARNING;
- case ch.qos.logback.classic.Level.ERROR_INT:
- return build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult
- .LogGroup.LogLevel.ERROR;
- default:
- return build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.ListTenantLogsResult
- .LogGroup.LogLevel.INFO;
- }
- }
-
- /** Converts logback Level to serializable LogLevel enum. */
- private com.tcn.exile.models.TenantLogsResult.LogGroup.LogLevel convertLogbackLevelToSerializable(
- ch.qos.logback.classic.Level logbackLevel) {
- switch (logbackLevel.toInt()) {
- case ch.qos.logback.classic.Level.TRACE_INT:
- case ch.qos.logback.classic.Level.DEBUG_INT:
- return com.tcn.exile.models.TenantLogsResult.LogGroup.LogLevel.DEBUG;
- case ch.qos.logback.classic.Level.INFO_INT:
- return com.tcn.exile.models.TenantLogsResult.LogGroup.LogLevel.INFO;
- case ch.qos.logback.classic.Level.WARN_INT:
- return com.tcn.exile.models.TenantLogsResult.LogGroup.LogLevel.WARNING;
- case ch.qos.logback.classic.Level.ERROR_INT:
- return com.tcn.exile.models.TenantLogsResult.LogGroup.LogLevel.ERROR;
- default:
- return com.tcn.exile.models.TenantLogsResult.LogGroup.LogLevel.INFO;
- }
- }
-
- /**
- * Sets the log level for a specific logger and returns the result in protobuf format for plugin
- * responses. This method handles dynamic log level changes during runtime and includes proper
- * tenant information.
- *
- * @param setLogLevelRequest The request containing the logger name and new log level
- * @param tenantKey The tenant identifier for proper tenant information
- * @return SetLogLevelResult in protobuf format ready for submission to gate
- */
- public build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.SetLogLevelResult
- setLogLevelWithTenant(
- build.buf.gen.tcnapi.exile.gate.v2.StreamJobsResponse.SetLogLevelRequest
- setLogLevelRequest,
- String tenantKey) {
- log.debug(
- "Setting log level for logger: {} to level: {} (tenant: {})",
- setLogLevelRequest.getLog(),
- setLogLevelRequest.getLogLevel(),
- tenantKey);
-
- try {
- // Get the logback logger context
- LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
-
- String loggerName = setLogLevelRequest.getLog();
-
- // Handle special case for root logger
- if ("ROOT".equalsIgnoreCase(loggerName) || loggerName.isEmpty()) {
- loggerName = ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME;
- }
-
- // Get the target logger
- ch.qos.logback.classic.Logger targetLogger = loggerContext.getLogger(loggerName);
-
- if (targetLogger == null) {
- log.warn("Logger '{}' not found", loggerName);
- return build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.SetLogLevelResult
- .newBuilder()
- .setTenant(createTenantInfoWithKey(tenantKey, "Logger not found: " + loggerName))
- .build();
- }
-
- // Convert the protobuf log level to logback level
- ch.qos.logback.classic.Level newLevel;
- try {
- newLevel = convertProtobufLevelToLogbackLevel(setLogLevelRequest.getLogLevel());
- } catch (IllegalArgumentException e) {
- log.warn("Invalid log level: {}", setLogLevelRequest.getLogLevel());
- return build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.SetLogLevelResult
- .newBuilder()
- .setTenant(
- createTenantInfoWithKey(
- tenantKey, "Invalid log level: " + setLogLevelRequest.getLogLevel()))
- .build();
- }
-
- // Get the old level for logging
- String oldLevel =
- targetLogger.getLevel() != null ? targetLogger.getLevel().toString() : "INHERITED";
-
- // Set the new level
- targetLogger.setLevel(newLevel);
-
- log.info(
- "Successfully changed log level for '{}' from '{}' to '{}' (tenant: {})",
- loggerName,
- oldLevel,
- newLevel.toString(),
- tenantKey);
-
- return build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.SetLogLevelResult
- .newBuilder()
- .setTenant(
- createTenantInfoWithKey(
- tenantKey,
- "Successfully changed log level for '"
- + loggerName
- + "' from '"
- + oldLevel
- + "' to '"
- + newLevel.toString()
- + "'"))
- .build();
-
- } catch (Exception e) {
- log.error(
- "Error setting log level for logger '{}' (tenant: {}): {}",
- setLogLevelRequest.getLog(),
- tenantKey,
- e.getMessage(),
- e);
- return build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.SetLogLevelResult
- .newBuilder()
- .setTenant(
- createTenantInfoWithKey(tenantKey, "Failed to set log level: " + e.getMessage()))
- .build();
- }
- }
-
- /**
- * Sets the log level for a specific logger and returns the result in protobuf format for plugin
- * responses. This method handles dynamic log level changes during runtime.
- *
- * @param setLogLevelRequest The request containing the logger name and new log level
- * @return SetLogLevelResult in protobuf format ready for submission to gate
- * @deprecated Use setLogLevelWithTenant instead for proper tenant information
- */
- @Deprecated
- public build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.SetLogLevelResult setLogLevel(
- build.buf.gen.tcnapi.exile.gate.v2.StreamJobsResponse.SetLogLevelRequest setLogLevelRequest) {
- return setLogLevelWithTenant(setLogLevelRequest, getHostname());
- }
-
- /**
- * Creates a Tenant object for the SetLogLevelResult with proper tenant key.
- *
- * @param tenantKey The tenant identifier
- * @param statusMessage A status message to include in the name field
- * @return Tenant object with system information
- */
- private build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.SetLogLevelResult.Tenant
- createTenantInfoWithKey(String tenantKey, String statusMessage) {
- Instant now = Instant.now();
- Timestamp updateTime =
- Timestamp.newBuilder().setSeconds(now.getEpochSecond()).setNanos(now.getNano()).build();
-
- // Get version information
- String satiVersion = "Unknown";
- String pluginVersion = "Unknown";
- try {
- satiVersion = com.tcn.exile.gateclients.v2.BuildVersion.getBuildVersion();
- } catch (Exception e) {
- log.debug("Could not get SATI version: {}", e.getMessage());
- }
-
- try {
- // Try to get plugin version from system properties or manifest
- String implVersion = this.getClass().getPackage().getImplementationVersion();
- if (implVersion != null) {
- pluginVersion = implVersion;
- }
- } catch (Exception e) {
- log.debug("Could not get plugin version: {}", e.getMessage());
- }
-
- // Use tenant key as the primary identifier
- String tenantName = tenantKey != null ? tenantKey : getHostname();
- if (statusMessage != null && !statusMessage.isEmpty()) {
- tenantName = tenantName + " (" + statusMessage + ")";
- }
-
- return build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.SetLogLevelResult.Tenant
- .newBuilder()
- .setName(tenantName)
- .setSatiVersion(satiVersion)
- .setPluginVersion(pluginVersion)
- .setUpdateTime(updateTime)
- .setConnectedGate(getHostname()) // Use hostname as connected gate info
- .build();
- }
-
- /**
- * Creates a Tenant object for the SetLogLevelResult. Since we don't have access to the actual
- * tenant context in DiagnosticsService, we create a basic tenant info with available system
- * information.
- *
- * @param statusMessage A status message to include in the name field
- * @return Tenant object with system information
- * @deprecated Use createTenantInfoWithKey instead for proper tenant information
- */
- @Deprecated
- private build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest.SetLogLevelResult.Tenant
- createTenantInfo(String statusMessage) {
- return createTenantInfoWithKey(null, statusMessage);
- }
-
- /** Converts protobuf LogLevel enum to logback Level. */
- private ch.qos.logback.classic.Level convertProtobufLevelToLogbackLevel(
- build.buf.gen.tcnapi.exile.gate.v2.StreamJobsResponse.SetLogLevelRequest.LogLevel
- protobufLevel) {
- switch (protobufLevel) {
- case DEBUG:
- return ch.qos.logback.classic.Level.DEBUG;
- case INFO:
- return ch.qos.logback.classic.Level.INFO;
- case WARNING:
- return ch.qos.logback.classic.Level.WARN;
- case ERROR:
- return ch.qos.logback.classic.Level.ERROR;
- case FATAL:
- return ch.qos.logback.classic.Level.ERROR; // Logback doesn't have FATAL, map to ERROR
- default:
- throw new IllegalArgumentException("Unknown protobuf log level: " + protobufLevel);
- }
- }
-
- private String getHostname() {
- try {
- return InetAddress.getLocalHost().getHostName();
- } catch (UnknownHostException e) {
- return System.getenv("HOSTNAME") != null ? System.getenv("HOSTNAME") : "unknown";
- }
- }
-
- private OperatingSystem collectOperatingSystemInfo() {
- OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean();
-
- long totalPhysicalMemory = -1;
- long availablePhysicalMemory = -1;
- long totalSwapSpace = -1;
- long availableSwapSpace = -1;
-
- // Try to get extended info if available
- try {
- if (osBean.getClass().getName().contains("com.sun.management")) {
- // Use reflection to access com.sun.management.OperatingSystemMXBean methods
- // Handle each method call separately to avoid one failure affecting others
- try {
- totalPhysicalMemory =
- (Long) osBean.getClass().getMethod("getTotalPhysicalMemorySize").invoke(osBean);
- } catch (Exception e) {
- // Suppress: fall back to default -1 when restricted
- }
-
- try {
- availablePhysicalMemory =
- (Long) osBean.getClass().getMethod("getFreePhysicalMemorySize").invoke(osBean);
- } catch (Exception e) {
- // Suppress: fall back to default -1 when restricted
- }
-
- try {
- totalSwapSpace =
- (Long) osBean.getClass().getMethod("getTotalSwapSpaceSize").invoke(osBean);
- } catch (Exception e) {
- // Suppress: fall back to default -1 when restricted
- }
-
- try {
- availableSwapSpace =
- (Long) osBean.getClass().getMethod("getFreeSwapSpaceSize").invoke(osBean);
- } catch (Exception e) {
- // Suppress: fall back to default -1 when restricted
- }
- }
- } catch (Exception e) {
- // Suppress overarching reflection access issues
- }
-
- return OperatingSystem.newBuilder()
- .setName(osBean.getName())
- .setVersion(osBean.getVersion())
- .setArchitecture(osBean.getArch())
- .setManufacturer(System.getProperty("os.name"))
- .setAvailableProcessors(osBean.getAvailableProcessors())
- .setSystemUptime(getSystemUptime())
- .setSystemLoadAverage(osBean.getSystemLoadAverage())
- .setTotalPhysicalMemory(totalPhysicalMemory)
- .setAvailablePhysicalMemory(availablePhysicalMemory)
- .setTotalSwapSpace(totalSwapSpace)
- .setAvailableSwapSpace(availableSwapSpace)
- .build();
- }
-
- private long getSystemUptime() {
- try {
- RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean();
- return runtimeBean.getUptime();
- } catch (Exception e) {
- log.debug("Could not get system uptime", e);
- return -1;
- }
- }
-
- private JavaRuntime collectJavaRuntimeInfo() {
- RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean();
-
- JavaRuntime.Builder builder =
- JavaRuntime.newBuilder()
- .setVersion(System.getProperty("java.version", ""))
- .setVendor(System.getProperty("java.vendor", ""))
- .setRuntimeName(System.getProperty("java.runtime.name", ""))
- .setVmName(System.getProperty("java.vm.name", ""))
- .setVmVersion(System.getProperty("java.vm.version", ""))
- .setVmVendor(System.getProperty("java.vm.vendor", ""))
- .setSpecificationName(System.getProperty("java.specification.name", ""))
- .setSpecificationVersion(System.getProperty("java.specification.version", ""))
- .setClassPath(System.getProperty("java.class.path", ""))
- .setLibraryPath(System.getProperty("java.library.path", ""))
- .setUptime(runtimeBean.getUptime())
- .setStartTime(runtimeBean.getStartTime())
- .setManagementSpecVersion(runtimeBean.getManagementSpecVersion());
-
- runtimeBean.getInputArguments().forEach(builder::addInputArguments);
-
- return builder.build();
- }
-
- private Hardware collectHardwareInfo() {
- String model = System.getenv("HOSTNAME") != null ? System.getenv("HOSTNAME") : "Unknown";
- String manufacturer = "Unknown";
- String serialNumber = "Unknown";
- String uuid = "Unknown";
-
- // Try to get hardware info from system files (Linux)
- try {
- if (System.getProperty("os.name").toLowerCase().contains("linux")) {
- model = readFileContent("/sys/devices/virtual/dmi/id/product_name", model);
- manufacturer = readFileContent("/sys/devices/virtual/dmi/id/sys_vendor", manufacturer);
- serialNumber = readFileContent("/sys/devices/virtual/dmi/id/product_serial", serialNumber);
- uuid = readFileContent("/sys/devices/virtual/dmi/id/product_uuid", uuid);
- }
- } catch (Exception e) {
- // Suppress diagnostic noise when hardware sysfs is inaccessible in containers
- }
-
- return Hardware.newBuilder()
- .setModel(model)
- .setManufacturer(manufacturer)
- .setSerialNumber(serialNumber)
- .setUuid(uuid)
- .setProcessor(collectProcessorInfo())
- .build();
- }
-
- private Processor collectProcessorInfo() {
- OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean();
-
- String processorName = System.getenv("PROCESSOR_IDENTIFIER");
- if (processorName == null) {
- processorName = readFileContent("/proc/cpuinfo", "Unknown");
- if (!"Unknown".equals(processorName)) {
- processorName =
- Arrays.stream(processorName.split("\n"))
- .filter(line -> line.startsWith("model name"))
- .findFirst()
- .map(line -> line.substring(line.indexOf(':') + 1).trim())
- .orElse("Unknown");
- }
- }
-
- return Processor.newBuilder()
- .setName(processorName)
- .setIdentifier(System.getProperty("java.vm.name", ""))
- .setArchitecture(System.getProperty("os.arch", ""))
- .setPhysicalProcessorCount(osBean.getAvailableProcessors())
- .setLogicalProcessorCount(Runtime.getRuntime().availableProcessors())
- .setMaxFrequency(-1L)
- .setCpu64Bit(
- System.getProperty("os.arch", "")
- .contains("64")) // Changed from setCpu64bit to setCpu64Bit
- .build();
- }
-
- private Memory collectMemoryInfo() {
- MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
- MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
- MemoryUsage nonHeapUsage = memoryBean.getNonHeapMemoryUsage();
-
- Memory.Builder builder =
- Memory.newBuilder()
- .setHeapMemoryUsed(heapUsage.getUsed())
- .setHeapMemoryMax(heapUsage.getMax())
- .setHeapMemoryCommitted(heapUsage.getCommitted())
- .setNonHeapMemoryUsed(nonHeapUsage.getUsed())
- .setNonHeapMemoryMax(nonHeapUsage.getMax())
- .setNonHeapMemoryCommitted(nonHeapUsage.getCommitted());
-
- ManagementFactory.getMemoryPoolMXBeans()
- .forEach(
- pool -> {
- MemoryUsage usage = pool.getUsage();
- builder.addMemoryPools(
- MemoryPool.newBuilder()
- .setName(pool.getName())
- .setType(pool.getType().toString())
- .setUsed(usage.getUsed())
- .setMax(usage.getMax())
- .setCommitted(usage.getCommitted())
- .build());
- });
-
- return builder.build();
- }
-
- private List collectStorageInfo() {
- List storageList = new ArrayList<>();
-
- File[] roots = File.listRoots();
- for (File root : roots) {
- storageList.add(
- Storage.newBuilder()
- .setName(root.getAbsolutePath())
- .setType("disk")
- .setModel("Unknown")
- .setSerialNumber("Unknown")
- .setSize(root.getTotalSpace())
- .build());
- }
-
- return storageList;
- }
-
- private Container collectContainerInfo() {
- boolean isContainer = detectContainer();
- String containerType = detectContainerType();
- String containerId = getContainerId();
- String containerName = System.getenv("HOSTNAME");
- String imageName = getImageName();
-
- Container.Builder builder =
- Container.newBuilder()
- .setIsContainer(isContainer)
- .setContainerType(containerType)
- .setContainerId(containerId)
- .setContainerName(containerName != null ? containerName : "")
- .setImageName(imageName);
-
- Map resourceLimits = new HashMap<>();
- Long memoryLimit =
- parseMemoryLimit(readFileContent("/sys/fs/cgroup/memory/memory.limit_in_bytes", null));
- if (memoryLimit != null) {
- resourceLimits.put("memory_limit", String.valueOf(memoryLimit));
- }
-
- Long cpuLimit = parseCpuLimit(readFileContent("/sys/fs/cgroup/cpu/cpu.cfs_quota_us", null));
- if (cpuLimit != null) {
- resourceLimits.put("cpu_limit", String.valueOf(cpuLimit));
- }
-
- String cpuRequest = System.getenv("CPU_REQUEST");
- if (cpuRequest != null) {
- resourceLimits.put("cpu_request", cpuRequest);
- }
-
- String memoryRequest = System.getenv("MEMORY_REQUEST");
- if (memoryRequest != null) {
- resourceLimits.put("memory_request", memoryRequest);
- }
-
- builder.putAllResourceLimits(resourceLimits);
-
- return builder.build();
- }
-
- private boolean detectContainer() {
- if (Files.exists(Paths.get("/.dockerenv"))) {
- return true;
- }
-
- String cgroupContent = readFileContent("/proc/1/cgroup", "");
- return DOCKER_PATTERN.matcher(cgroupContent).find()
- || KUBERNETES_PATTERN.matcher(cgroupContent).find();
- }
-
- private String detectContainerType() {
- if (System.getenv("KUBERNETES_SERVICE_HOST") != null) {
- return "kubernetes";
- }
- if (Files.exists(Paths.get("/.dockerenv"))) {
- return "docker";
- }
-
- String cgroupContent = readFileContent("/proc/1/cgroup", "");
- if (KUBERNETES_PATTERN.matcher(cgroupContent).find()) {
- return "kubernetes";
- }
- if (DOCKER_PATTERN.matcher(cgroupContent).find()) {
- return "docker";
- }
-
- return "unknown";
- }
-
- private String getContainerId() {
- String cgroupContent = readFileContent("/proc/self/cgroup", "");
- if (!cgroupContent.isEmpty()) {
- String[] lines = cgroupContent.split("\n");
- for (String line : lines) {
- if (line.contains("docker") || line.contains("containerd")) {
- String[] parts = line.split("/");
- if (parts.length > 0) {
- String lastPart = parts[parts.length - 1];
- if (lastPart.length() >= 12) {
- return lastPart.substring(0, 12);
- }
- }
- }
- }
- }
- return System.getenv("HOSTNAME") != null ? System.getenv("HOSTNAME") : "";
- }
-
- private String getImageName() {
- String[] imageEnvVars = {
- "IMAGE_NAME", "DOCKER_IMAGE", "CONTAINER_IMAGE", "POD_CONTAINER_IMAGE"
- };
-
- for (String envVar : imageEnvVars) {
- String value = System.getenv(envVar);
- if (value != null && !value.isEmpty()) {
- return value;
- }
- }
-
- return "unknown";
- }
-
- private Map collectKubernetesLabels() {
- Map labels = new HashMap<>();
- System.getenv().entrySet().stream()
- .filter(entry -> entry.getKey().startsWith("LABEL_"))
- .forEach(entry -> labels.put(entry.getKey().substring(6).toLowerCase(), entry.getValue()));
- return labels;
- }
-
- private Map collectKubernetesAnnotations() {
- Map annotations = new HashMap<>();
- System.getenv().entrySet().stream()
- .filter(entry -> entry.getKey().startsWith("ANNOTATION_"))
- .forEach(
- entry -> annotations.put(entry.getKey().substring(11).toLowerCase(), entry.getValue()));
- return annotations;
- }
-
- private Long parseMemoryLimit(String content) {
- if (content == null || content.trim().isEmpty()) {
- return null;
- }
- try {
- long limit = Long.parseLong(content.trim());
- return limit > (1024L * 1024L * 1024L * 1024L) ? null : limit;
- } catch (NumberFormatException e) {
- return null;
- }
- }
-
- private Long parseCpuLimit(String content) {
- if (content == null || content.trim().isEmpty()) {
- return null;
- }
- try {
- return Long.parseLong(content.trim());
- } catch (NumberFormatException e) {
- return null;
- }
- }
-
- private EnvironmentVariables collectEnvironmentVariables() {
- Set sensitiveKeys =
- Set.of(
- "PASSWORD",
- "SECRET",
- "TOKEN",
- "KEY",
- "CREDENTIAL",
- "API_KEY",
- "ACCESS_TOKEN",
- "PRIVATE_KEY");
-
- Map env = System.getenv();
-
- return EnvironmentVariables.newBuilder()
- .setLanguage(env.getOrDefault("LANGUAGE", ""))
- .setPath(env.getOrDefault("PATH", ""))
- .setHostname(env.getOrDefault("HOSTNAME", ""))
- .setLcAll(env.getOrDefault("LC_ALL", ""))
- .setJavaHome(env.getOrDefault("JAVA_HOME", ""))
- .setJavaVersion(env.getOrDefault("JAVA_VERSION", ""))
- .setLang(env.getOrDefault("LANG", ""))
- .setHome(env.getOrDefault("HOME", ""))
- .build();
- }
-
- private SystemProperties collectSystemProperties() {
- Properties props = System.getProperties();
-
- return SystemProperties.newBuilder()
- // Java Specification
- .setJavaSpecificationVersion(props.getProperty("java.specification.version", ""))
- .setJavaSpecificationVendor(props.getProperty("java.specification.vendor", ""))
- .setJavaSpecificationName(props.getProperty("java.specification.name", ""))
- .setJavaSpecificationMaintenanceVersion(
- props.getProperty("java.specification.maintenance.version", ""))
-
- // Java Version Info
- .setJavaVersion(props.getProperty("java.version", ""))
- .setJavaVersionDate(props.getProperty("java.version.date", ""))
- .setJavaVendor(props.getProperty("java.vendor", ""))
- .setJavaVendorVersion(props.getProperty("java.vendor.version", ""))
- .setJavaVendorUrl(props.getProperty("java.vendor.url", ""))
- .setJavaVendorUrlBug(props.getProperty("java.vendor.url.bug", ""))
-
- // Java Runtime
- .setJavaRuntimeName(props.getProperty("java.runtime.name", ""))
- .setJavaRuntimeVersion(props.getProperty("java.runtime.version", ""))
- .setJavaHome(props.getProperty("java.home", ""))
- .setJavaClassPath(props.getProperty("java.class.path", ""))
- .setJavaLibraryPath(props.getProperty("java.library.path", ""))
- .setJavaClassVersion(props.getProperty("java.class.version", ""))
-
- // Java VM
- .setJavaVmName(props.getProperty("java.vm.name", ""))
- .setJavaVmVersion(props.getProperty("java.vm.version", ""))
- .setJavaVmVendor(props.getProperty("java.vm.vendor", ""))
- .setJavaVmInfo(props.getProperty("java.vm.info", ""))
- .setJavaVmSpecificationVersion(props.getProperty("java.vm.specification.version", ""))
- .setJavaVmSpecificationVendor(props.getProperty("java.vm.specification.vendor", ""))
- .setJavaVmSpecificationName(props.getProperty("java.vm.specification.name", ""))
- .setJavaVmCompressedOopsMode(props.getProperty("java.vm.compressedOopsMode", ""))
-
- // Operating System
- .setOsName(props.getProperty("os.name", ""))
- .setOsVersion(props.getProperty("os.version", ""))
- .setOsArch(props.getProperty("os.arch", ""))
-
- // User Info
- .setUserName(props.getProperty("user.name", ""))
- .setUserHome(props.getProperty("user.home", ""))
- .setUserDir(props.getProperty("user.dir", ""))
- .setUserTimezone(props.getProperty("user.timezone", ""))
- .setUserCountry(props.getProperty("user.country", ""))
- .setUserLanguage(props.getProperty("user.language", ""))
-
- // File System
- .setFileSeparator(props.getProperty("file.separator", ""))
- .setPathSeparator(props.getProperty("path.separator", ""))
- .setLineSeparator(props.getProperty("line.separator", ""))
- .setFileEncoding(props.getProperty("file.encoding", ""))
- .setNativeEncoding(props.getProperty("native.encoding", ""))
-
- // Sun/Oracle Specific
- .setSunJnuEncoding(props.getProperty("sun.jnu.encoding", ""))
- .setSunArchDataModel(props.getProperty("sun.arch.data.model", ""))
- .setSunJavaLauncher(props.getProperty("sun.java.launcher", ""))
- .setSunBootLibraryPath(props.getProperty("sun.boot.library.path", ""))
- .setSunJavaCommand(props.getProperty("sun.java.command", ""))
- .setSunCpuEndian(props.getProperty("sun.cpu.endian", ""))
- .setSunManagementCompiler(props.getProperty("sun.management.compiler", ""))
- .setSunIoUnicodeEncoding(props.getProperty("sun.io.unicode.encoding", ""))
-
- // JDK/Debug
- .setJdkDebug(props.getProperty("jdk.debug", ""))
- .setJavaIoTmpdir(props.getProperty("java.io.tmpdir", ""))
-
- // Application Specific
- .setEnv(props.getProperty("env", ""))
- .setMicronautClassloaderLogging(props.getProperty("micronaut.classloader.logging", ""))
-
- // Third Party Libraries
- .setIoNettyAllocatorMaxOrder(props.getProperty("io.netty.allocator.maxOrder", ""))
- .setIoNettyProcessId(props.getProperty("io.netty.processId", ""))
- .setIoNettyMachineId(props.getProperty("io.netty.machineId", ""))
- .setComZaxxerHikariPoolNumber(props.getProperty("com.zaxxer.hikari.pool_number", ""))
- .build();
- }
-
- private String readFileContent(String filePath, String defaultValue) {
- try {
- Path path = Paths.get(filePath);
- if (Files.exists(path)) {
- return Files.readString(path).trim();
- }
- } catch (IOException e) {
- // Intentionally suppress logs for unreadable or restricted system files
- }
- return defaultValue;
- }
-
- public com.tcn.exile.models.DiagnosticsResult collectSerdeableDiagnostics() {
- return com.tcn.exile.models.DiagnosticsResult.fromProto(collectSystemDiagnostics());
- }
-
- /**
- * Common method to collect logs from MemoryAppender using reflection. This eliminates code
- * duplication between different collection methods.
- *
- * @param startTimeMs Start time in milliseconds since epoch, or null for no start limit
- * @param endTimeMs End time in milliseconds since epoch, or null for no end limit
- * @return LogCollectionResult containing logs and success status
- */
- private LogCollectionResult collectLogsFromMemoryAppender(Long startTimeMs, Long endTimeMs) {
- try {
- // Use reflection to access MemoryAppenderInstance.getInstance()
- Class memoryAppenderInstanceClass =
- Class.forName("com.tcn.exile.memlogger.MemoryAppenderInstance");
- Method getInstanceMethod = memoryAppenderInstanceClass.getMethod("getInstance");
- Object memoryAppenderInstance = getInstanceMethod.invoke(null);
-
- if (memoryAppenderInstance == null) {
- log.warn("MemoryAppender instance is null - no in-memory logs available");
- return LogCollectionResult.success(new ArrayList<>());
- }
-
- List logs;
-
- // Check if time filtering is requested
- if (startTimeMs != null && endTimeMs != null) {
- // Use reflection to call getEventsInTimeRange() on the MemoryAppender instance
- Method getEventsInTimeRangeMethod =
- memoryAppenderInstance
- .getClass()
- .getMethod("getEventsInTimeRange", long.class, long.class);
- @SuppressWarnings("unchecked")
- List retrievedLogs =
- (List)
- getEventsInTimeRangeMethod.invoke(memoryAppenderInstance, startTimeMs, endTimeMs);
-
- logs = retrievedLogs != null ? retrievedLogs : new ArrayList<>();
- log.debug(
- "Retrieved {} logs within time range {} to {}", logs.size(), startTimeMs, endTimeMs);
- } else {
- // Use reflection to call getEventsAsList() on the MemoryAppender instance
- Method getEventsAsListMethod =
- memoryAppenderInstance.getClass().getMethod("getEventsAsList");
- @SuppressWarnings("unchecked")
- List retrievedLogs =
- (List) getEventsAsListMethod.invoke(memoryAppenderInstance);
-
- logs = retrievedLogs != null ? retrievedLogs : new ArrayList<>();
- log.debug("Retrieved {} logs (no time range specified)", logs.size());
- }
-
- return LogCollectionResult.success(logs);
-
- } catch (ClassNotFoundException e) {
- String errorMsg =
- "MemoryAppender classes not found - memory logging not available: " + e.getMessage();
- log.warn(errorMsg);
- return LogCollectionResult.failure(errorMsg);
- } catch (Exception e) {
- String errorMsg =
- "Failed to retrieve logs from memory appender using reflection: " + e.getMessage();
- log.warn(errorMsg);
- return LogCollectionResult.failure(errorMsg);
- }
- }
-
- /** Helper method to convert protobuf Timestamp to milliseconds since epoch. */
- private long convertTimestampToMs(com.google.protobuf.Timestamp timestamp) {
- return timestamp.getSeconds() * 1000 + timestamp.getNanos() / 1000000;
- }
-
- /** Helper method to create a protobuf Timestamp from milliseconds since epoch. */
- private com.google.protobuf.Timestamp createTimestamp(long timeMs) {
- return com.google.protobuf.Timestamp.newBuilder()
- .setSeconds(timeMs / 1000)
- .setNanos((int) ((timeMs % 1000) * 1000000))
- .build();
- }
-
- /**
- * Collects metrics for all HikariCP connection pools in the application.
- *
- * @return List of HikariPoolMetrics objects with data about each connection pool
- */
- private List collectHikariMetrics() {
- log.info("Collecting HikariCP connection pool metrics...");
- List poolMetrics = new ArrayList<>();
-
- try {
- // Get the platform MBean server
- MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
-
- // Search for all HikariCP pools
- Set hikariPoolNames =
- mBeanServer.queryNames(new ObjectName("com.zaxxer.hikari:type=Pool *"), null);
-
- if (hikariPoolNames.isEmpty()) {
- log.info("No HikariCP connection pools found.");
- return poolMetrics;
- }
-
- log.info("Found {} HikariCP connection pool(s)", hikariPoolNames.size());
-
- // For each pool, collect metrics
- for (ObjectName poolName : hikariPoolNames) {
- String poolNameStr = poolName.getKeyProperty("type").split(" ")[1];
- if (poolNameStr.startsWith("(") && poolNameStr.endsWith(")")) {
- poolNameStr = poolNameStr.substring(1, poolNameStr.length() - 1);
- }
-
- try {
- // Basic metrics
- int activeConnections = (Integer) mBeanServer.getAttribute(poolName, "ActiveConnections");
- int idleConnections = (Integer) mBeanServer.getAttribute(poolName, "IdleConnections");
- int totalConnections = (Integer) mBeanServer.getAttribute(poolName, "TotalConnections");
- int threadsAwaitingConnection =
- (Integer) mBeanServer.getAttribute(poolName, "ThreadsAwaitingConnection");
-
- // Create builder for this pool
- HikariPoolMetrics.Builder poolMetricBuilder =
- HikariPoolMetrics.newBuilder()
- .setPoolName(poolNameStr)
- .setActiveConnections(activeConnections)
- .setIdleConnections(idleConnections)
- .setTotalConnections(totalConnections)
- .setThreadsAwaitingConnection(threadsAwaitingConnection);
-
- // Try to get configuration metrics
- try {
- ObjectName configName =
- new ObjectName("com.zaxxer.hikari:type=PoolConfig (" + poolNameStr + ")");
- if (mBeanServer.isRegistered(configName)) {
- long connectionTimeout =
- (Long) mBeanServer.getAttribute(configName, "ConnectionTimeout");
- long validationTimeout =
- (Long) mBeanServer.getAttribute(configName, "ValidationTimeout");
- long idleTimeout = (Long) mBeanServer.getAttribute(configName, "IdleTimeout");
- long maxLifetime = (Long) mBeanServer.getAttribute(configName, "MaxLifetime");
- int minimumIdle = (Integer) mBeanServer.getAttribute(configName, "MinimumIdle");
- int maximumPoolSize =
- (Integer) mBeanServer.getAttribute(configName, "MaximumPoolSize");
- long leakDetectionThreshold =
- (Long) mBeanServer.getAttribute(configName, "LeakDetectionThreshold");
- String poolName_ = (String) mBeanServer.getAttribute(configName, "PoolName");
-
- // Build pool config
- HikariPoolMetrics.PoolConfig.Builder configBuilder =
- HikariPoolMetrics.PoolConfig.newBuilder()
- .setPoolName(poolName_)
- .setConnectionTimeout(connectionTimeout)
- .setValidationTimeout(validationTimeout)
- .setIdleTimeout(idleTimeout)
- .setMaxLifetime(maxLifetime)
- .setMinimumIdle(minimumIdle)
- .setMaximumPoolSize(maximumPoolSize)
- .setLeakDetectionThreshold(leakDetectionThreshold);
-
- // Get JDBC URL and username from plugin configuration
- String jdbcUrl = "";
- String username = "";
- try {
- Collection plugins =
- applicationContext.getBeansOfType(PluginInterface.class);
- for (PluginInterface plugin : plugins) {
- var pluginStatus = plugin.getPluginStatus();
- Map internalConfig = pluginStatus.internalConfig();
-
- if (internalConfig != null && !internalConfig.isEmpty()) {
- Object jdbcUrlObj = internalConfig.get("jdbc_url");
- Object jdbcUserObj = internalConfig.get("jdbc_user");
-
- if (jdbcUrlObj != null && jdbcUserObj != null) {
- jdbcUrl = jdbcUrlObj.toString();
- username = jdbcUserObj.toString();
- log.debug(
- "Retrieved JDBC config from plugin: url={}, user={}", jdbcUrl, username);
- break;
- }
- }
- }
- } catch (Exception e) {
- log.warn("Failed to get JDBC config from plugins: {}", e.getMessage());
- }
-
- configBuilder.setJdbcUrl(jdbcUrl).setUsername(username);
-
- poolMetricBuilder.setPoolConfig(configBuilder);
- }
- } catch (Exception e) {
- log.debug("Error accessing pool configuration: {}", e.getMessage());
- }
-
- // Collect extended metrics if available
- Map extendedMetrics = new HashMap<>();
- try {
- Set metricNames =
- mBeanServer.queryNames(
- new ObjectName("metrics:name=hikaricp." + poolNameStr + ".*"), null);
-
- for (ObjectName metricName : metricNames) {
- String metricType = metricName.getKeyProperty("name");
- try {
- Object value = mBeanServer.getAttribute(metricName, "Value");
- extendedMetrics.put(metricType, String.valueOf(value));
- } catch (Exception e) {
- log.debug("Could not get metric value for {}: {}", metricType, e.getMessage());
- }
- }
- } catch (Exception e) {
- log.debug("Error accessing Dropwizard metrics: {}", e.getMessage());
- }
-
- poolMetricBuilder.putAllExtendedMetrics(extendedMetrics);
- poolMetrics.add(poolMetricBuilder.build());
-
- } catch (Exception e) {
- log.error("Error getting metrics for pool {}: {}", poolNameStr, e.getMessage());
- }
- }
- } catch (Exception e) {
- log.error("Error collecting HikariCP metrics", e);
- }
-
- return poolMetrics;
- }
-
- /**
- * Collects configuration details from the config file.
- *
- * @return ConfigDetails object with API endpoint and certificate information
- */
- private ConfigDetails collectConfigDetails() {
- log.info("Collecting configuration file details...");
- ConfigDetails.Builder configBuilder = ConfigDetails.newBuilder();
-
- // Define the config paths and filename
- final String CONFIG_FILE_NAME = "com.tcn.exiles.sati.config.cfg";
- final List watchList = List.of(Path.of("/workdir/config"), Path.of("workdir/config"));
-
- try {
- // Find the first valid directory
- Optional configDir =
- watchList.stream().filter(path -> path.toFile().exists()).findFirst();
-
- if (configDir.isEmpty()) {
- log.error("No valid config directory found");
- return configBuilder.build();
- }
-
- Path configFile = configDir.get().resolve(CONFIG_FILE_NAME);
- if (!configFile.toFile().exists()) {
- log.error("Config file not found: {}", configFile);
- return configBuilder.build();
- }
-
- log.info("Found config file: {}", configFile);
- byte[] base64EncodedData = Files.readAllBytes(configFile);
- String dataString = new String(base64EncodedData);
-
- // Trim and ensure proper base64 length
- byte[] data = dataString.trim().getBytes();
- byte[] decodedData;
-
- try {
- decodedData = Base64.getDecoder().decode(data);
- } catch (IllegalArgumentException e) {
- // Try removing the last byte which might be a newline
- log.debug("Failed to decode base64, trying with truncated data");
- decodedData = Base64.getDecoder().decode(Arrays.copyOf(data, data.length - 1));
- }
-
- // Convert to string for processing
- String jsonString = new String(decodedData);
-
- // Extract JSON values
- String apiEndpoint = extractJsonValue(jsonString, "api_endpoint");
- String certificateName = extractJsonValue(jsonString, "certificate_name");
- String certificateDescription = extractJsonValue(jsonString, "certificate_description");
-
- // Build Config Details
- configBuilder
- .setApiEndpoint(apiEndpoint)
- .setCertificateName(certificateName)
- .setCertificateDescription(certificateDescription);
-
- } catch (IOException e) {
- log.error("Error reading or parsing config file", e);
- } catch (Exception e) {
- log.error("Unexpected error processing config file", e);
- }
-
- return configBuilder.build();
- }
-
- /**
- * Simple method to extract a JSON value by key from a JSON string. This is a basic implementation
- * that works for first-level string values in JSON.
- */
- private String extractJsonValue(String jsonString, String key) {
- String searchPattern = "\"" + key + "\"\\s*:\\s*\"([^\"]*)\"";
- java.util.regex.Pattern pattern = java.util.regex.Pattern.compile(searchPattern);
- java.util.regex.Matcher matcher = pattern.matcher(jsonString);
-
- if (matcher.find()) {
- return matcher.group(1);
- }
- return "Not found";
- }
-
- /**
- * Get JDBC connection details for diagnostic purposes.
- *
- * @return Map containing JDBC connection information
- */
- public Map getJdbcConnectionDetails() {
- Map jdbcDetails = new HashMap<>();
-
- try {
- MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
- Set hikariPoolNames =
- mBeanServer.queryNames(new ObjectName("com.zaxxer.hikari:type=Pool *"), null);
-
- for (ObjectName poolName : hikariPoolNames) {
- String poolNameStr = poolName.getKeyProperty("type").split(" ")[1];
- if (poolNameStr.startsWith("(") && poolNameStr.endsWith(")")) {
- poolNameStr = poolNameStr.substring(1, poolNameStr.length() - 1);
- }
-
- Map poolInfo = new HashMap<>();
-
- // Get basic connection metrics
- poolInfo.put("activeConnections", mBeanServer.getAttribute(poolName, "ActiveConnections"));
- poolInfo.put("idleConnections", mBeanServer.getAttribute(poolName, "IdleConnections"));
- poolInfo.put("totalConnections", mBeanServer.getAttribute(poolName, "TotalConnections"));
-
- // Get configuration details
- try {
- ObjectName configName =
- new ObjectName("com.zaxxer.hikari:type=PoolConfig (" + poolNameStr + ")");
- if (mBeanServer.isRegistered(configName)) {
- poolInfo.put("jdbcUrl", mBeanServer.getAttribute(configName, "JdbcUrl"));
- poolInfo.put("username", mBeanServer.getAttribute(configName, "Username"));
-
- // Try to get driver class name
- try {
- poolInfo.put(
- "driverClassName", mBeanServer.getAttribute(configName, "DriverClassName"));
- } catch (Exception e) {
- log.debug("Driver class name not available: {}", e.getMessage());
- poolInfo.put("driverClassName", "Unknown");
- }
- }
- } catch (Exception e) {
- log.debug("Error accessing pool configuration: {}", e.getMessage());
- }
-
- jdbcDetails.put(poolNameStr, poolInfo);
- }
- } catch (Exception e) {
- log.error("Error collecting JDBC connection details", e);
- }
-
- return jdbcDetails;
- }
-
- /**
- * Get event stream statistics from Plugin instances directly.
- *
- * @return Map containing event stream stats
- */
- public Map getEventStreamStats() {
- Map eventStreamStats = new HashMap<>();
-
- try {
- // Get all Plugin instances from the application context
- Collection plugins =
- applicationContext.getBeansOfType(PluginInterface.class);
-
- if (plugins.isEmpty()) {
- log.info("No Plugin instances found");
- eventStreamStats.put("status", "Not available");
- return eventStreamStats;
- }
-
- log.info("Found {} plugin instance(s)", plugins.size());
-
- for (PluginInterface plugin : plugins) {
- try {
- var pluginStatus = plugin.getPluginStatus();
- String pluginName = pluginStatus.name(); // PluginStatus is a record
-
- Map streamInfo = new HashMap<>();
- streamInfo.put("status", pluginStatus.running() ? "running" : "stopped");
- streamInfo.put("maxJobs", pluginStatus.queueMaxSize());
- streamInfo.put("runningJobs", pluginStatus.queueActiveCount());
- streamInfo.put("completedJobs", pluginStatus.queueCompletedJobs());
- streamInfo.put("queuedJobs", pluginStatus.queueActiveCount());
-
- eventStreamStats.put(pluginName + "-plugin", streamInfo);
-
- log.debug(
- "Collected stats for plugin {}: running={}, maxJobs={}, activeJobs={}, completedJobs={}",
- pluginName,
- pluginStatus.running(),
- pluginStatus.queueMaxSize(),
- pluginStatus.queueActiveCount(),
- pluginStatus.queueCompletedJobs());
-
- } catch (Exception e) {
- log.error("Error getting stats for plugin: {}", e.getMessage(), e);
- }
- }
-
- } catch (Exception e) {
- log.error("Error collecting plugin-based event stream stats", e);
- eventStreamStats.put("error", e.getMessage());
- }
-
- return eventStreamStats;
- }
-
- /**
- * Collects event stream statistics for the application's event stream.
- *
- * @return EventStreamStats object with aggregated data about the application's event stream
- */
- private EventStreamStats collectEventStreamStats() {
- log.info("Collecting event stream statistics...");
-
- try {
- // Get all Plugin instances from the application context
- Collection plugins =
- applicationContext.getBeansOfType(PluginInterface.class);
-
- if (plugins.isEmpty()) {
- log.info("No Plugin instances found");
- return EventStreamStats.newBuilder()
- .setStreamName("application")
- .setStatus("not available")
- .setMaxJobs(-1)
- .setRunningJobs(-1)
- .setCompletedJobs(-1)
- .setQueuedJobs(-1)
- .build();
- }
-
- log.info("Found {} plugin instance(s)", plugins.size());
-
- // Aggregate stats from all plugins
- String overallStatus = "stopped";
- int totalMaxJobs = 0;
- int totalRunningJobs = 0;
- long totalCompletedJobs = 0;
- int totalQueuedJobs = 0;
- boolean anyPluginRunning = false;
-
- for (PluginInterface plugin : plugins) {
- try {
- var pluginStatus = plugin.getPluginStatus();
-
- if (pluginStatus.running()) {
- anyPluginRunning = true;
- }
-
- totalMaxJobs += pluginStatus.queueMaxSize();
- totalRunningJobs += pluginStatus.queueActiveCount();
- totalCompletedJobs += pluginStatus.queueCompletedJobs();
-
- // Calculate queued jobs as max - active
- int queuedJobs =
- Math.max(0, pluginStatus.queueMaxSize() - pluginStatus.queueActiveCount());
- totalQueuedJobs += queuedJobs;
-
- log.debug(
- "Plugin stats: running={}, maxJobs={}, activeJobs={}, completedJobs={}",
- pluginStatus.running(),
- pluginStatus.queueMaxSize(),
- pluginStatus.queueActiveCount(),
- pluginStatus.queueCompletedJobs());
-
- } catch (Exception e) {
- log.error("Error getting stats for plugin: {}", e.getMessage(), e);
- }
- }
-
- // Determine overall status
- if (anyPluginRunning) {
- overallStatus = "running";
- } else if (totalMaxJobs > 0) {
- overallStatus = "stopped";
- } else {
- overallStatus = "not configured";
- }
-
- // Create aggregated EventStreamStats
- return EventStreamStats.newBuilder()
- .setStreamName("application")
- .setStatus(overallStatus)
- .setMaxJobs(totalMaxJobs)
- .setRunningJobs(totalRunningJobs)
- .setCompletedJobs(totalCompletedJobs)
- .setQueuedJobs(totalQueuedJobs)
- .build();
-
- } catch (Exception e) {
- log.error("Error collecting event stream statistics", e);
- return EventStreamStats.newBuilder()
- .setStreamName("application")
- .setStatus("error: " + e.getMessage())
- .setMaxJobs(-1)
- .setRunningJobs(-1)
- .setCompletedJobs(-1)
- .setQueuedJobs(-1)
- .build();
- }
- }
-}
diff --git a/core/src/main/java/com/tcn/exile/gateclients/UnconfiguredException.java b/core/src/main/java/com/tcn/exile/gateclients/UnconfiguredException.java
deleted file mode 100644
index 1ce2785..0000000
--- a/core/src/main/java/com/tcn/exile/gateclients/UnconfiguredException.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * (C) 2017-2024 TCN Inc. All rights reserved.
- *
- * Licensed 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
- *
- * https://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.
- *
- */
-package com.tcn.exile.gateclients;
-
-public class UnconfiguredException extends Exception {
- public UnconfiguredException() {
- super();
- }
-
- public UnconfiguredException(String message) {
- super(message);
- }
-
- public UnconfiguredException(String message, Throwable cause) {
- super(message, cause);
- }
-
- public UnconfiguredException(Throwable cause) {
- super(cause);
- }
-}
diff --git a/core/src/main/java/com/tcn/exile/gateclients/v2/BuildVersion.java b/core/src/main/java/com/tcn/exile/gateclients/v2/BuildVersion.java
deleted file mode 100644
index c69030c..0000000
--- a/core/src/main/java/com/tcn/exile/gateclients/v2/BuildVersion.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * (C) 2017-2024 TCN Inc. All rights reserved.
- *
- * Licensed 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
- *
- * https://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.
- *
- */
-package com.tcn.exile.gateclients.v2;
-
-public class BuildVersion {
- public static String getBuildVersion() {
- return BuildVersion.class.getPackage().getImplementationVersion();
- }
-}
diff --git a/core/src/main/java/com/tcn/exile/gateclients/v2/GateClient.java b/core/src/main/java/com/tcn/exile/gateclients/v2/GateClient.java
deleted file mode 100644
index 218c4a7..0000000
--- a/core/src/main/java/com/tcn/exile/gateclients/v2/GateClient.java
+++ /dev/null
@@ -1,328 +0,0 @@
-/*
- * (C) 2017-2025 TCN Inc. All rights reserved.
- *
- * Licensed 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
- *
- * https://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.
- *
- */
-package com.tcn.exile.gateclients.v2;
-
-import build.buf.gen.tcnapi.exile.gate.v2.*;
-import com.tcn.exile.config.Config;
-import com.tcn.exile.gateclients.UnconfiguredException;
-import com.tcn.exile.log.LogCategory;
-import com.tcn.exile.log.StructuredLogger;
-import com.tcn.exile.models.OrgInfo;
-import io.grpc.ManagedChannel;
-import io.grpc.StatusRuntimeException;
-import java.util.Iterator;
-import java.util.concurrent.TimeUnit;
-
-public class GateClient extends GateClientAbstract {
- private static final StructuredLogger log = new StructuredLogger(GateClient.class);
- private static final int DEFAULT_TIMEOUT_SECONDS = 30;
-
- public GateClient(String tenant, Config currentConfig) {
- super(tenant, currentConfig);
- }
-
- @Override
- public void start() {
- // this does not need any implementation
- }
-
- protected GateServiceGrpc.GateServiceBlockingStub getStub(ManagedChannel channel) {
- return GateServiceGrpc.newBlockingStub(channel)
- .withDeadlineAfter(DEFAULT_TIMEOUT_SECONDS, TimeUnit.SECONDS);
- }
-
- public T executeRequest(String operationName, GrpcOperation grpcOperation) {
- try {
- var result = grpcOperation.execute(getChannel());
- if (result == null) {
- throw new RuntimeException("Received null response from " + operationName);
- }
- return result;
- } catch (UnconfiguredException e) {
- log.error(
- LogCategory.GRPC,
- "OperationFailed",
- "Failed to execute %s operation: %s",
- operationName,
- e.getMessage());
- throw new RuntimeException(e);
- } catch (StatusRuntimeException e) {
- if (handleStatusRuntimeException(e)) {
- log.warn(
- LogCategory.GRPC,
- "ConnectionIssue",
- "Connection issue during %s operation, channel reset: %s",
- operationName,
- e.getMessage());
- throw new RuntimeException(
- "Connection issue during " + operationName + ", please retry", e);
- }
- log.error(
- LogCategory.GRPC,
- "GrpcError",
- "gRPC error during %s operation: %s (%s)",
- operationName,
- e.getMessage(),
- e.getStatus().getCode());
- throw new RuntimeException("Failed to execute " + operationName, e);
- } catch (Exception e) {
- log.error(
- LogCategory.GRPC,
- "UnexpectedError",
- "Unexpected error during %s operation: %s",
- operationName,
- e.getMessage());
- throw new RuntimeException("Failed to execute " + operationName, e);
- }
- }
-
- @FunctionalInterface
- private interface GrpcOperation {
- T execute(ManagedChannel channel);
- }
-
- // Organization details retrieval
- public OrgInfo getOrganizationInfo() {
- return executeRequest(
- "getOrganizationInfo",
- client -> {
- var result =
- getStub(client).getOrganizationInfo(GetOrganizationInfoRequest.newBuilder().build());
- return new OrgInfo(result.getOrgName(), result.getOrgName());
- });
- }
-
- // Job results submission (max 2MB)
- public SubmitJobResultsResponse submitJobResults(SubmitJobResultsRequest request) {
- log.info(
- LogCategory.GRPC,
- "SubmitJobResults",
- "GateClient submit job results request: %s",
- request.getJobId());
- try {
- return executeRequest(
- "submitJobResults",
- client -> {
- var response = getStub(client).submitJobResults(request);
- if (response == null) {
- throw new RuntimeException("Received null response from submitJobResults");
- }
- return response;
- });
- } catch (Exception e) {
- log.error(
- LogCategory.GRPC,
- "SubmitJobResultsFailed",
- "Failed to submit job results for job %s: %s",
- request.getJobId(),
- e.getMessage());
- throw new RuntimeException("Failed to submit job results", e);
- }
- }
-
- // Agent state management
- public GetAgentStatusResponse getAgentStatus(GetAgentStatusRequest request) {
- return executeRequest("getAgentStatus", client -> getStub(client).getAgentStatus(request));
- }
-
- public UpdateAgentStatusResponse updateAgentStatus(UpdateAgentStatusRequest request) {
- return executeRequest(
- "updateAgentStatus", client -> getStub(client).updateAgentStatus(request));
- }
-
- public Iterator listAgents(ListAgentsRequest request) {
- return executeRequest("listAgents", client -> getStub(client).listAgents(request));
- }
-
- public UpsertAgentResponse upsertAgent(UpsertAgentRequest request) {
- return executeRequest("upsertAgent", client -> getStub(client).upsertAgent(request));
- }
-
- public GetAgentByIdResponse getAgentById(GetAgentByIdRequest request) {
- return executeRequest("getAgentById", client -> getStub(client).getAgentById(request));
- }
-
- public GetAgentByPartnerIdResponse getAgentByPartnerId(GetAgentByPartnerIdRequest request) {
- return executeRequest(
- "getAgentByPartnerId", client -> getStub(client).getAgentByPartnerId(request));
- }
-
- // Telephony operations
- public DialResponse dial(DialRequest request) {
- return executeRequest("dial", client -> getStub(client).dial(request));
- }
-
- public ListNCLRulesetNamesResponse listNCLRulesetNames(ListNCLRulesetNamesRequest request) {
- return executeRequest(
- "listNCLRulesetNames", client -> getStub(client).listNCLRulesetNames(request));
- }
-
- // Recording controls
- public StartCallRecordingResponse startCallRecording(StartCallRecordingRequest request) {
- return executeRequest(
- "startCallRecording", client -> getStub(client).startCallRecording(request));
- }
-
- public StopCallRecordingResponse stopCallRecording(StopCallRecordingRequest request) {
- return executeRequest(
- "stopCallRecording", client -> getStub(client).stopCallRecording(request));
- }
-
- public GetRecordingStatusResponse getRecordingStatus(GetRecordingStatusRequest request) {
- return executeRequest(
- "getRecordingStatus", client -> getStub(client).getRecordingStatus(request));
- }
-
- // Scrub list management
- public ListScrubListsResponse listScrubLists(ListScrubListsRequest request) {
- return executeRequest("listScrubLists", client -> getStub(client).listScrubLists(request));
- }
-
- public AddScrubListEntriesResponse addScrubListEntries(AddScrubListEntriesRequest request) {
- return executeRequest(
- "addScrubListEntries", client -> getStub(client).addScrubListEntries(request));
- }
-
- public UpdateScrubListEntryResponse updateScrubListEntry(UpdateScrubListEntryRequest request) {
- return executeRequest(
- "updateScrubListEntry", client -> getStub(client).updateScrubListEntry(request));
- }
-
- public RemoveScrubListEntriesResponse removeScrubListEntries(
- RemoveScrubListEntriesRequest request) {
- return executeRequest(
- "removeScrubListEntries", client -> getStub(client).removeScrubListEntries(request));
- }
-
- public LogResponse log(LogRequest request) {
- return executeRequest("log", client -> getStub(client).log(request));
- }
-
- public AddAgentCallResponseResponse addAgentCallResponse(AddAgentCallResponseRequest request) {
- return executeRequest(
- "addAgentCallResponse", client -> getStub(client).addAgentCallResponse(request));
- }
-
- public ListHuntGroupPauseCodesResponse listHuntGroupPauseCodes(
- ListHuntGroupPauseCodesRequest request) {
- return executeRequest(
- "listHuntGroupPauseCodes", client -> getStub(client).listHuntGroupPauseCodes(request));
- }
-
- public PutCallOnSimpleHoldResponse putCallOnSimpleHold(PutCallOnSimpleHoldRequest request) {
- return executeRequest(
- "putCallOnSimpleHold", client -> getStub(client).putCallOnSimpleHold(request));
- }
-
- public TakeCallOffSimpleHoldResponse takeCallOffSimpleHold(TakeCallOffSimpleHoldRequest request) {
- return executeRequest(
- "takeCallOffSimpleHold", client -> getStub(client).takeCallOffSimpleHold(request));
- }
-
- public HoldTransferMemberCallerResponse holdTransferMemberCaller(
- HoldTransferMemberCallerRequest request) {
- return executeRequest(
- "holdTransferMemberCaller", client -> getStub(client).holdTransferMemberCaller(request));
- }
-
- public UnholdTransferMemberCallerResponse unholdTransferMemberCaller(
- UnholdTransferMemberCallerRequest request) {
- return executeRequest(
- "unholdTransferMemberCaller",
- client -> getStub(client).unholdTransferMemberCaller(request));
- }
-
- public HoldTransferMemberAgentResponse holdTransferMemberAgent(
- HoldTransferMemberAgentRequest request) {
- return executeRequest(
- "holdTransferMemberAgent", client -> getStub(client).holdTransferMemberAgent(request));
- }
-
- public UnholdTransferMemberAgentResponse unholdTransferMemberAgent(
- UnholdTransferMemberAgentRequest request) {
- return executeRequest(
- "unholdTransferMemberAgent", client -> getStub(client).unholdTransferMemberAgent(request));
- }
-
- public MuteAgentResponse muteAgent(MuteAgentRequest request) {
- return executeRequest("muteAgent", client -> getStub(client).muteAgent(request));
- }
-
- public UnmuteAgentResponse unmuteAgent(UnmuteAgentRequest request) {
- return executeRequest("unmuteAgent", client -> getStub(client).unmuteAgent(request));
- }
-
- public RotateCertificateResponse rotateCertificate(RotateCertificateRequest request) {
- return executeRequest(
- "rotateCertificate", client -> getStub(client).rotateCertificate(request));
- }
-
- public Iterator searchVoiceRecordings(
- SearchVoiceRecordingsRequest request) {
- return executeRequest(
- "searchVoiceRecordings", client -> getStub(client).searchVoiceRecordings(request));
- }
-
- public GetVoiceRecordingDownloadLinkResponse getVoiceRecordingDownloadLink(
- GetVoiceRecordingDownloadLinkRequest request) {
- return executeRequest(
- "getVoiceRecordingDownloadLink",
- client -> getStub(client).getVoiceRecordingDownloadLink(request));
- }
-
- public ListSearchableRecordingFieldsResponse listSearchableRecordingFields(
- ListSearchableRecordingFieldsRequest request) {
- return executeRequest(
- "listSearchableRecordingFields",
- client -> getStub(client).listSearchableRecordingFields(request));
- }
-
- public CreateRecordingLabelResponse createRecordingLabel(CreateRecordingLabelRequest request) {
- return executeRequest(
- "createRecordingLabel", client -> getStub(client).createRecordingLabel(request));
- }
-
- public ListSkillsResponse ListSkills(ListSkillsRequest request) {
- return executeRequest("listSkills", client -> getStub(client).listSkills(request));
- }
-
- // List all skills assigned to an agent, and their proficiency
- public ListAgentSkillsResponse ListAgentSkills(ListAgentSkillsRequest request) {
- return executeRequest("listAgentSkills", client -> getStub(client).listAgentSkills(request));
- }
-
- // Assign a skill to an agent
- public AssignAgentSkillResponse AssignAgentSkill(AssignAgentSkillRequest request) {
- return executeRequest("assignAgentSkill", client -> getStub(client).assignAgentSkill(request));
- }
-
- // Unassign a skill from an agent
- public UnassignAgentSkillResponse UnassignAgentSkill(UnassignAgentSkillRequest request) {
- return executeRequest(
- "unassignAgentSkill", client -> getStub(client).unassignAgentSkill(request));
- }
-
- public TransferResponse transfer(TransferRequest request) {
- return executeRequest("transfer", client -> getStub(client).transfer(request));
- }
-
- public AddRecordToJourneyBufferResponse addRecordToJourneyBuffer(
- AddRecordToJourneyBufferRequest request) {
- return executeRequest(
- "addRecordToJourneyBuffer", client -> getStub(client).addRecordToJourneyBuffer(request));
- }
-}
diff --git a/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientAbstract.java b/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientAbstract.java
deleted file mode 100644
index 36dc224..0000000
--- a/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientAbstract.java
+++ /dev/null
@@ -1,578 +0,0 @@
-/*
- * (C) 2017-2026 TCN Inc. All rights reserved.
- *
- * Licensed 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
- *
- * https://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.
- *
- */
-package com.tcn.exile.gateclients.v2;
-
-import com.tcn.exile.config.Config;
-import com.tcn.exile.gateclients.UnconfiguredException;
-import io.grpc.Grpc;
-import io.grpc.ManagedChannel;
-import io.grpc.Status;
-import io.grpc.StatusRuntimeException;
-import io.grpc.TlsChannelCredentials;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.time.Duration;
-import java.time.Instant;
-import java.time.temporal.ChronoUnit;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ThreadLocalRandom;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.concurrent.locks.ReentrantLock;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Base class for bidirectional gRPC stream clients.
- *
- *
Provides shared infrastructure for stream lifecycle management including exponential backoff
- * with jitter, hung connection detection, connection tracking, and graceful shutdown. Subclasses
- * implement {@link #runStream()} for stream-specific logic and {@link #getStreamName()} for
- * logging.
- */
-public abstract class GateClientAbstract {
- private static final Logger log = LoggerFactory.getLogger(GateClientAbstract.class);
-
- // Stream lifecycle constants
- protected static final long STREAM_TIMEOUT_MINUTES = 5;
- protected static final long HUNG_CONNECTION_THRESHOLD_SECONDS = 45;
-
- // Backoff configuration
- private static final long BACKOFF_BASE_MS = 2000;
- private static final long BACKOFF_MAX_MS = 30000;
- private static final double BACKOFF_JITTER = 0.2;
-
- // Channel management
- private ManagedChannel sharedChannel;
- private final ReentrantLock lock = new ReentrantLock();
-
- private Config currentConfig = null;
- protected final String tenant;
-
- // Connection tracking — shared across all stream subclasses
- protected final AtomicReference lastMessageTime = new AtomicReference<>();
- protected final AtomicReference lastDisconnectTime = new AtomicReference<>();
- protected final AtomicReference reconnectionStartTime = new AtomicReference<>();
- protected final AtomicReference connectionEstablishedTime = new AtomicReference<>();
- protected final AtomicLong totalReconnectionAttempts = new AtomicLong(0);
- protected final AtomicLong successfulReconnections = new AtomicLong(0);
- protected final AtomicReference lastErrorType = new AtomicReference<>();
- protected final AtomicLong consecutiveFailures = new AtomicLong(0);
- protected final AtomicBoolean isRunning = new AtomicBoolean(false);
-
- public GateClientAbstract(String tenant, Config currentConfig) {
- this.currentConfig = currentConfig;
- this.tenant = tenant;
-
- Runtime.getRuntime()
- .addShutdownHook(
- new Thread(
- () -> {
- log.info("Shutdown hook triggered - cleaning up gRPC channels");
- forceShutdownSharedChannel();
- },
- "gRPC-Channel-Cleanup"));
- }
-
- // ---------------------------------------------------------------------------
- // Stream lifecycle — template method pattern
- // ---------------------------------------------------------------------------
-
- /**
- * Human-readable name for this stream, used in log messages. Override in subclasses that use the
- * template {@link #start()} method (e.g. "EventStream", "JobQueue").
- */
- protected String getStreamName() {
- return getClass().getSimpleName();
- }
-
- /**
- * Run a single stream session. Called by the template {@link #start()} method. Subclasses that
- * use the shared lifecycle must override this. Legacy subclasses that override start() directly
- * can ignore it.
- */
- protected void runStream()
- throws UnconfiguredException, InterruptedException, HungConnectionException {
- throw new UnsupportedOperationException(
- getStreamName() + " must override runStream() or start()");
- }
-
- /**
- * Template method that handles the full stream lifecycle: backoff, try/catch, error tracking.
- * Each invocation represents one connection attempt.
- */
- public void start() {
- if (isUnconfigured()) {
- log.warn("{} is unconfigured, cannot start", getStreamName());
- return;
- }
-
- // Prevent concurrent invocations from the fixed-rate scheduler
- if (!isRunning.compareAndSet(false, true)) {
- return;
- }
-
- // Exponential backoff: sleep before retrying if we have consecutive failures
- long backoffMs = computeBackoffMs();
- if (backoffMs > 0) {
- log.debug(
- "[{}] Waiting {}ms before reconnect (consecutive failures: {})",
- getStreamName(),
- backoffMs,
- consecutiveFailures.get());
- try {
- Thread.sleep(backoffMs);
- } catch (InterruptedException e) {
- Thread.currentThread().interrupt();
- isRunning.set(false);
- return;
- }
- }
-
- try {
- log.debug("[{}] Starting, checking configuration status", getStreamName());
- reconnectionStartTime.set(Instant.now());
- resetChannelBackoff();
- runStream();
- } catch (HungConnectionException e) {
- log.warn("[{}] Connection appears hung: {}", getStreamName(), e.getMessage());
- lastErrorType.set("HungConnection");
- consecutiveFailures.incrementAndGet();
- } catch (UnconfiguredException e) {
- log.error("[{}] Configuration error: {}", getStreamName(), e.getMessage());
- lastErrorType.set("UnconfiguredException");
- consecutiveFailures.incrementAndGet();
- } catch (InterruptedException e) {
- log.info("[{}] Interrupted", getStreamName());
- Thread.currentThread().interrupt();
- } catch (Exception e) {
- if (isRoutineStreamClosure(e)) {
- log.debug("[{}] Stream closed by server (routine reconnect)", getStreamName());
- } else {
- log.error("[{}] Error: {}", getStreamName(), e.getMessage(), e);
- }
- lastErrorType.set(e.getClass().getSimpleName());
- consecutiveFailures.incrementAndGet();
- } finally {
- totalReconnectionAttempts.incrementAndGet();
- lastDisconnectTime.set(Instant.now());
- isRunning.set(false);
- onStreamDisconnected();
- log.debug("[{}] Stream session ended", getStreamName());
- }
- }
-
- /** Hook called in the finally block of start(). Subclasses can clear observer refs here. */
- protected void onStreamDisconnected() {}
-
- // ---------------------------------------------------------------------------
- // Shared stream helpers
- // ---------------------------------------------------------------------------
-
- /** Record that the first server response was received and the connection is established. */
- protected void onConnectionEstablished() {
- connectionEstablishedTime.set(Instant.now());
- successfulReconnections.incrementAndGet();
- consecutiveFailures.set(0);
- lastErrorType.set(null);
-
- log.info(
- "[{}] Connection established (took {})",
- getStreamName(),
- Duration.between(reconnectionStartTime.get(), connectionEstablishedTime.get()));
- }
-
- /** Check if the connection is hung (no messages received within threshold). */
- protected void checkForHungConnection() throws HungConnectionException {
- Instant lastMsg = lastMessageTime.get();
- if (lastMsg == null) {
- lastMsg = connectionEstablishedTime.get();
- }
- if (lastMsg != null
- && lastMsg.isBefore(
- Instant.now().minus(HUNG_CONNECTION_THRESHOLD_SECONDS, ChronoUnit.SECONDS))) {
- throw new HungConnectionException(
- "No messages received since " + lastMsg + " - connection appears hung");
- }
- }
-
- /**
- * Wait for a stream latch to complete, periodically checking for hung connections. Returns when
- * the latch counts down, the timeout expires, or a hung connection is detected.
- */
- protected void awaitStreamWithHungDetection(CountDownLatch latch)
- throws InterruptedException, HungConnectionException {
- long startTime = System.currentTimeMillis();
- long maxDurationMs = TimeUnit.MINUTES.toMillis(STREAM_TIMEOUT_MINUTES);
-
- while ((System.currentTimeMillis() - startTime) < maxDurationMs) {
- if (latch.await(HUNG_CONNECTION_THRESHOLD_SECONDS, TimeUnit.SECONDS)) {
- return; // Stream completed
- }
- checkForHungConnection();
- }
- }
-
- /** Compute backoff delay with jitter based on consecutive failure count. */
- private long computeBackoffMs() {
- long failures = consecutiveFailures.get();
- if (failures <= 0) {
- return 0;
- }
- long delayMs = BACKOFF_BASE_MS * (1L << Math.min(failures - 1, 10));
- double jitter = 1.0 + (ThreadLocalRandom.current().nextDouble() * 2 - 1) * BACKOFF_JITTER;
- return Math.min((long) (delayMs * jitter), BACKOFF_MAX_MS);
- }
-
- /**
- * Build base stream status map with connection tracking fields. Subclasses should call this and
- * add their own stream-specific counters.
- */
- protected Map buildStreamStatus() {
- Instant lastDisconnect = lastDisconnectTime.get();
- Instant connectionEstablished = connectionEstablishedTime.get();
- Instant reconnectStart = reconnectionStartTime.get();
- Instant lastMessage = lastMessageTime.get();
-
- Map status = new HashMap<>();
- status.put("isRunning", isRunning.get());
- status.put("totalReconnectionAttempts", totalReconnectionAttempts.get());
- status.put("successfulReconnections", successfulReconnections.get());
- status.put("consecutiveFailures", consecutiveFailures.get());
- status.put("lastDisconnectTime", lastDisconnect != null ? lastDisconnect.toString() : null);
- status.put(
- "connectionEstablishedTime",
- connectionEstablished != null ? connectionEstablished.toString() : null);
- status.put("reconnectionStartTime", reconnectStart != null ? reconnectStart.toString() : null);
- status.put("lastErrorType", lastErrorType.get());
- status.put("lastMessageTime", lastMessage != null ? lastMessage.toString() : null);
- return status;
- }
-
- // ---------------------------------------------------------------------------
- // Graceful shutdown
- // ---------------------------------------------------------------------------
-
- /** Override in subclasses to add stream-specific stop logic (e.g. closing observers). */
- public void stop() {
- doStop();
- }
-
- /** Shared shutdown logic: set running flag, shut down channel. */
- protected void doStop() {
- isRunning.set(false);
- shutdown();
- }
-
- // ---------------------------------------------------------------------------
- // Configuration and channel management
- // ---------------------------------------------------------------------------
-
- public Config getConfig() {
- return currentConfig;
- }
-
- public boolean isUnconfigured() {
- if (currentConfig == null) {
- return true;
- }
- return currentConfig.isUnconfigured();
- }
-
- public Map getStatus() {
- return Map.of(
- "running", true,
- "configured", !getConfig().isUnconfigured(),
- "api_endpoint", getConfig().getApiEndpoint(),
- "org", getConfig().getOrg(),
- "expiration_date", getConfig().getExpirationDate(),
- "certificate_expiration_date", getConfig().getExpirationDate(),
- "certificate_description", getConfig().getCertificateDescription(),
- "channel_active", isChannelActive());
- }
-
- private boolean isChannelActive() {
- ManagedChannel channel = sharedChannel;
- return channel != null && !channel.isShutdown() && !channel.isTerminated();
- }
-
- protected void shutdown() {
- log.debug("Tenant: {} - Attempting shutdown of static shared gRPC channel.", tenant);
-
- lock.lock();
- try {
- ManagedChannel channelToShutdown = sharedChannel;
- if (channelToShutdown != null
- && !channelToShutdown.isShutdown()
- && !channelToShutdown.isTerminated()) {
- log.debug(
- "Tenant: {} - Attempting graceful shutdown of shared channel {}",
- tenant,
- channelToShutdown);
-
- channelToShutdown.shutdown();
- try {
- if (!channelToShutdown.awaitTermination(10, TimeUnit.SECONDS)) {
- log.warn(
- "Tenant: {} - Shared channel {} did not terminate gracefully after 10s, forcing shutdown.",
- tenant,
- channelToShutdown);
- channelToShutdown.shutdownNow();
- if (!channelToShutdown.awaitTermination(5, TimeUnit.SECONDS)) {
- log.error(
- "Tenant: {} - Shared channel {} failed to terminate even after forced shutdown.",
- tenant,
- channelToShutdown);
- }
- }
- log.info(
- "Tenant: {} - Successfully shut down shared channel {}", tenant, channelToShutdown);
- } catch (InterruptedException e) {
- log.error(
- "Tenant: {} - Interrupted while waiting for shared channel shutdown, forcing shutdown now.",
- tenant,
- e);
- channelToShutdown.shutdownNow();
- Thread.currentThread().interrupt();
- }
-
- sharedChannel = null;
- } else {
- log.debug("Tenant: {} - Shared channel is already null, shut down, or terminated.", tenant);
- if (sharedChannel != null && (sharedChannel.isShutdown() || sharedChannel.isTerminated())) {
- sharedChannel = null;
- }
- }
- } finally {
- lock.unlock();
- }
- }
-
- private void forceShutdownSharedChannel() {
- log.info("forceShudown called, aquiring lock");
- lock.lock();
- try {
- ManagedChannel channelToShutdown = sharedChannel;
- if (channelToShutdown != null) {
- log.info("Force shutting down shared gRPC channel during application shutdown");
- channelToShutdown.shutdownNow();
- try {
- if (!channelToShutdown.awaitTermination(5, TimeUnit.SECONDS)) {
- log.warn("Shared channel did not terminate within 5 seconds during force shutdown");
- }
- } catch (InterruptedException e) {
- Thread.currentThread().interrupt();
- log.warn("Interrupted during force shutdown of shared channel");
- }
- sharedChannel = null;
- }
- } finally {
- lock.unlock();
- }
- }
-
- public ManagedChannel getChannel() throws UnconfiguredException {
- long getChannelStartTime = System.currentTimeMillis();
- ManagedChannel localChannel = sharedChannel;
- if (localChannel == null || localChannel.isShutdown() || localChannel.isTerminated()) {
-
- long beforeLockAcquisition = System.currentTimeMillis();
- log.debug(
- "[LOCK-TIMING] getChannel attempting to acquire lock for tenant: {} at {}ms",
- tenant,
- beforeLockAcquisition);
-
- lock.lock();
-
- long afterLockAcquisition = System.currentTimeMillis();
- long lockWaitTime = afterLockAcquisition - beforeLockAcquisition;
- if (lockWaitTime > 100) {
- log.warn(
- "[LOCK-TIMING] getChannel lock acquired for tenant: {} after {}ms WAIT (potential contention!)",
- tenant,
- lockWaitTime);
- } else {
- log.debug(
- "[LOCK-TIMING] getChannel lock acquired for tenant: {} after {}ms",
- tenant,
- lockWaitTime);
- }
- try {
- localChannel = sharedChannel;
-
- var shutdown = localChannel == null || localChannel.isShutdown();
- var terminated = localChannel == null || localChannel.isTerminated();
-
- log.debug(
- "localChannel is null: {}, isShutdown: {}, isTerminated: {}",
- localChannel == null,
- shutdown,
- terminated);
-
- if (localChannel == null || localChannel.isShutdown() || localChannel.isTerminated()) {
- long beforeCreateChannel = System.currentTimeMillis();
- log.debug(
- "[LOCK-TIMING] getChannel creating new channel for tenant: {} at {}ms (lock held for {}ms so far)",
- tenant,
- beforeCreateChannel,
- beforeCreateChannel - afterLockAcquisition);
-
- localChannel = createNewChannel();
-
- long afterCreateChannel = System.currentTimeMillis();
- log.debug(
- "[LOCK-TIMING] getChannel channel created for tenant: {} at {}ms (createNewChannel took: {}ms, lock held total: {}ms)",
- tenant,
- afterCreateChannel,
- afterCreateChannel - beforeCreateChannel,
- afterCreateChannel - afterLockAcquisition);
-
- sharedChannel = localChannel;
- }
- } catch (Exception e) {
- log.error(
- "Tenant: {} - Error creating new static shared gRPC channel for config: {}",
- tenant,
- getConfig(),
- e);
- throw new UnconfiguredException("Error creating new static shared gRPC channel", e);
- } finally {
- long beforeUnlock = System.currentTimeMillis();
- lock.unlock();
- long afterUnlock = System.currentTimeMillis();
- long totalLockHeldTime = afterUnlock - afterLockAcquisition;
- log.debug(
- "[LOCK-TIMING] getChannel lock released for tenant: {} at {}ms (lock held for {}ms, total getChannel: {}ms)",
- tenant,
- afterUnlock,
- totalLockHeldTime,
- afterUnlock - getChannelStartTime);
- }
- } else {
- log.debug(
- "getChannel no new channel needed, returning localChannel null: {}, isShutdown: {}, isTerminated: {}",
- localChannel == null,
- localChannel.isShutdown(),
- localChannel.isTerminated());
- }
-
- return localChannel;
- }
-
- private ManagedChannel createNewChannel() throws UnconfiguredException {
- try {
- var channelCredentials =
- TlsChannelCredentials.newBuilder()
- .trustManager(new ByteArrayInputStream(getConfig().getRootCert().getBytes()))
- .keyManager(
- new ByteArrayInputStream(getConfig().getPublicCert().getBytes()),
- new ByteArrayInputStream(getConfig().getPrivateKey().getBytes()))
- .build();
-
- var hostname = getConfig().getApiHostname();
- var port = getConfig().getApiPort();
- var chan =
- Grpc.newChannelBuilderForAddress(hostname, port, channelCredentials)
- .keepAliveTime(32, TimeUnit.SECONDS)
- .keepAliveTimeout(30, TimeUnit.SECONDS)
- .keepAliveWithoutCalls(true)
- .idleTimeout(30, TimeUnit.MINUTES)
- .overrideAuthority("exile-proxy")
- .build();
- log.info("Managed Channel created for {}:{}", hostname, port);
-
- return chan;
-
- } catch (IOException e) {
- log.error("Tenant: {} - IOException during shared channel creation", tenant, e);
- throw new UnconfiguredException(
- "TCN Gate client configuration error during channel creation", e);
- } catch (UnconfiguredException e) {
- log.error("Tenant: {} - Configuration error during shared channel creation", tenant, e);
- throw e;
- } catch (Exception e) {
- log.error("Tenant: {} - Unexpected error during shared channel creation", tenant, e);
- throw new UnconfiguredException("Unexpected error configuring TCN Gate client channel", e);
- }
- }
-
- /**
- * Reset gRPC's internal connect backoff on the shared channel. This forces the name resolver to
- * immediately retry DNS resolution instead of waiting for its own exponential backoff timer.
- */
- protected void resetChannelBackoff() {
- ManagedChannel channel = sharedChannel;
- if (channel != null && !channel.isShutdown() && !channel.isTerminated()) {
- channel.resetConnectBackoff();
- }
- }
-
- /** Resets the gRPC channel after a connection failure. */
- protected void resetChannel() {
- log.info("Tenant: {} - Resetting static shared gRPC channel after connection failure.", tenant);
- shutdown();
- }
-
- /** Handle StatusRuntimeException, resetting channel on UNAVAILABLE. */
- protected boolean handleStatusRuntimeException(StatusRuntimeException e) {
- if (e.getStatus().getCode() == Status.Code.UNAVAILABLE) {
- log.warn(
- "Tenant: {} - Connection unavailable, resetting channel: {}", tenant, e.getMessage());
- resetChannel();
- return true;
- }
- return false;
- }
-
- /** Get channel statistics for monitoring. */
- public Map getChannelStats() {
- ManagedChannel channel = sharedChannel;
- if (channel != null) {
- return Map.of(
- "isShutdown", channel.isShutdown(),
- "isTerminated", channel.isTerminated(),
- "authority", channel.authority(),
- "state", channel.getState(false).toString());
- }
- return Map.of("channel", "null");
- }
-
- /** Exception for hung connection detection. */
- public static class HungConnectionException extends Exception {
- public HungConnectionException(String message) {
- super(message);
- }
- }
-
- private boolean isRoutineStreamClosure(Exception e) {
- Throwable cause = e;
- while (cause != null) {
- if (cause instanceof StatusRuntimeException sre
- && sre.getStatus().getCode() == Status.Code.UNAVAILABLE
- && sre.getMessage() != null
- && sre.getMessage().contains("NO_ERROR")) {
- return true;
- }
- cause = cause.getCause();
- }
- return false;
- }
-}
diff --git a/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientConfiguration.java b/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientConfiguration.java
deleted file mode 100644
index 33c7ed4..0000000
--- a/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientConfiguration.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * (C) 2017-2025 TCN Inc. All rights reserved.
- *
- * Licensed 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
- *
- * https://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.
- *
- */
-package com.tcn.exile.gateclients.v2;
-
-import build.buf.gen.tcnapi.exile.gate.v2.GateServiceGrpc;
-import build.buf.gen.tcnapi.exile.gate.v2.GetClientConfigurationRequest;
-import build.buf.gen.tcnapi.exile.gate.v2.GetClientConfigurationResponse;
-import com.tcn.exile.config.Config;
-import com.tcn.exile.gateclients.UnconfiguredException;
-import com.tcn.exile.models.PluginConfigEvent;
-import com.tcn.exile.plugin.PluginInterface;
-import io.grpc.StatusRuntimeException;
-import io.micronaut.scheduling.annotation.Scheduled;
-import java.util.concurrent.TimeUnit;
-
-public class GateClientConfiguration extends GateClientAbstract {
- PluginConfigEvent event = null;
-
- PluginInterface plugin;
-
- protected static final org.slf4j.Logger log =
- org.slf4j.LoggerFactory.getLogger(GateClientConfiguration.class);
-
- /** Redacts sensitive information from JSON configuration payload. */
- private String redactConfigPayloadForLogging(String payload) {
- if (payload == null || payload.isBlank()) {
- return payload;
- }
-
- // Redact password field
- String redacted =
- payload.replaceAll(
- "\"database_password\"\\s*:\\s*\"[^\"]*\"", "\"database_password\":\"***REDACTED***\"");
-
- // Redact username field
- redacted =
- redacted.replaceAll(
- "\"database_username\"\\s*:\\s*\"[^\"]*\"", "\"database_username\":\"***REDACTED***\"");
-
- // Redact jdbcUser field
- redacted =
- redacted.replaceAll("\"jdbcUser\"\\s*:\\s*\"[^\"]*\"", "\"jdbcUser\":\"***REDACTED***\"");
-
- // Redact certificate fields
- redacted =
- redacted.replaceAll(
- "\"trust_store_cert\"\\s*:\\s*\"[^\"]*\"",
- "\"trust_store_cert\":\"***CERTIFICATE_REDACTED***\"");
- redacted =
- redacted.replaceAll(
- "\"key_store_cert\"\\s*:\\s*\"[^\"]*\"",
- "\"key_store_cert\":\"***CERTIFICATE_REDACTED***\"");
-
- return redacted;
- }
-
- /** Creates a redacted version of PluginConfigEvent for safe logging. */
- private String redactEventForLogging(PluginConfigEvent event) {
- if (event == null) {
- return "null";
- }
-
- return String.format(
- "PluginConfigEvent{orgId='%s', orgName='%s', configurationName='%s', configurationPayload='%s', unconfigured=%s}",
- event.getOrgId(),
- event.getOrgName(),
- event.getConfigurationName(),
- redactConfigPayloadForLogging(event.getConfigurationPayload()),
- event.isUnconfigured());
- }
-
- /** Creates a redacted version of GetClientConfigurationResponse for safe logging. */
- private String redactResponseForLogging(GetClientConfigurationResponse response) {
- if (response == null) {
- return "null";
- }
-
- return String.format(
- "GetClientConfigurationResponse{orgId='%s', orgName='%s', configName='%s', configPayload='%s'}",
- response.getOrgId(),
- response.getOrgName(),
- response.getConfigName(),
- redactConfigPayloadForLogging(response.getConfigPayload()));
- }
-
- public GateClientConfiguration(String tenant, Config currentConfig, PluginInterface plugin) {
- super(tenant, currentConfig);
- this.plugin = plugin;
- this.event = new PluginConfigEvent(this).setOrgId(currentConfig.getOrg()).setUnconfigured(true);
- }
-
- @Override
- @Scheduled(fixedDelay = "10s")
- public void start() {
- try {
- var client =
- GateServiceGrpc.newBlockingStub(getChannel())
- .withDeadlineAfter(300, TimeUnit.SECONDS)
- .withWaitForReady();
- GetClientConfigurationResponse response =
- client.getClientConfiguration(GetClientConfigurationRequest.newBuilder().build());
-
- log.debug(
- "Tenant: {} got config response: {} current event: {}",
- this.tenant,
- redactResponseForLogging(response),
- redactEventForLogging(this.event));
- var newEvent =
- new PluginConfigEvent(this)
- .setConfigurationName(response.getConfigName())
- .setConfigurationPayload(response.getConfigPayload())
- .setOrgId(response.getOrgId())
- .setOrgName(response.getOrgName())
- .setUnconfigured(false);
- if (!newEvent.equals(event)) {
- log.debug(
- "Tenant: {} - Received new configuration event: {}, update plugin config",
- tenant,
- redactEventForLogging(newEvent));
- event = newEvent;
- this.plugin.setConfig(event);
- }
- } catch (UnconfiguredException e) {
- log.debug("Tenant: {} - Configuration not set, skipping get client configuration", tenant);
- } catch (StatusRuntimeException e) {
- if (!handleStatusRuntimeException(e)) {
- log.error("Tenant: {} - Failed to get client configuration", tenant, e);
- } else {
- log.warn(
- "Tenant: {} - Transient gRPC error while getting client configuration, will retry",
- tenant,
- e);
- }
- }
- }
-}
diff --git a/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientEventStream.java b/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientEventStream.java
deleted file mode 100644
index 39e6011..0000000
--- a/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientEventStream.java
+++ /dev/null
@@ -1,413 +0,0 @@
-/*
- * (C) 2017-2026 TCN Inc. All rights reserved.
- *
- * Licensed 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
- *
- * https://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.
- *
- */
-package com.tcn.exile.gateclients.v2;
-
-import build.buf.gen.tcnapi.exile.gate.v2.Event;
-import build.buf.gen.tcnapi.exile.gate.v2.EventStreamRequest;
-import build.buf.gen.tcnapi.exile.gate.v2.EventStreamResponse;
-import build.buf.gen.tcnapi.exile.gate.v2.GateServiceGrpc;
-import com.tcn.exile.config.Config;
-import com.tcn.exile.gateclients.UnconfiguredException;
-import com.tcn.exile.log.LogCategory;
-import com.tcn.exile.log.StructuredLogger;
-import com.tcn.exile.plugin.PluginInterface;
-import io.grpc.stub.StreamObserver;
-import jakarta.annotation.PreDestroy;
-import java.time.Instant;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.atomic.AtomicReference;
-
-/**
- * Bidirectional event streaming with acknowledgment using the EventStream API.
- *
- *
The client drives the loop: sends a request (with ACK IDs + event count), server responds with
- * events, client processes them and sends the next request with ACKs. This repeats until the
- * server's 5-minute context timeout expires.
- */
-public class GateClientEventStream extends GateClientAbstract {
- private static final StructuredLogger log = new StructuredLogger(GateClientEventStream.class);
-
- private static final int BATCH_SIZE = 100;
-
- private final PluginInterface plugin;
- private final AtomicLong eventsProcessed = new AtomicLong(0);
- private final AtomicLong eventsFailed = new AtomicLong(0);
-
- // Pending ACKs buffer — survives stream reconnections.
- // Event IDs are added after successful processing and removed only after
- // successful send to the server. If a stream breaks before ACKs are sent,
- // they carry over to the next connection attempt.
- private final List pendingAcks = new ArrayList<>();
-
- // Stream observer for sending requests/ACKs
- private final AtomicReference> requestObserverRef =
- new AtomicReference<>();
-
- public GateClientEventStream(String tenant, Config currentConfig, PluginInterface plugin) {
- super(tenant, currentConfig);
- this.plugin = plugin;
- }
-
- @Override
- protected String getStreamName() {
- return "EventStream";
- }
-
- @Override
- protected void onStreamDisconnected() {
- requestObserverRef.set(null);
- }
-
- @Override
- protected void runStream()
- throws UnconfiguredException, InterruptedException, HungConnectionException {
- var latch = new CountDownLatch(1);
- var errorRef = new AtomicReference();
- var firstResponseReceived = new AtomicBoolean(false);
-
- var responseObserver =
- new StreamObserver() {
- @Override
- public void onNext(EventStreamResponse response) {
- lastMessageTime.set(Instant.now());
-
- if (firstResponseReceived.compareAndSet(false, true)) {
- onConnectionEstablished();
- }
-
- if (response.getEventsCount() == 0) {
- log.debug(
- LogCategory.GRPC, "EmptyBatch", "Received empty event batch, requesting next");
- // Brief pause to avoid hot-looping when no events are available.
- // The server responds instantly to empty polls, so without this
- // delay we'd loop every ~40ms burning CPU and network.
- try {
- Thread.sleep(10000);
- } catch (InterruptedException e) {
- Thread.currentThread().interrupt();
- return;
- }
- sendNextRequest();
- return;
- }
-
- log.debug(
- LogCategory.GRPC,
- "EventsReceived",
- "Received %d events from stream",
- response.getEventsCount());
-
- processBatch(response.getEventsList());
- sendNextRequest();
- }
-
- @Override
- public void onError(Throwable t) {
- log.warn(LogCategory.GRPC, "StreamError", "Event stream error: %s", t.getMessage());
- errorRef.set(t);
- latch.countDown();
- }
-
- @Override
- public void onCompleted() {
- log.info(LogCategory.GRPC, "StreamCompleted", "Event stream completed by server");
- latch.countDown();
- }
- };
-
- // Open bidirectional stream
- var requestObserver = GateServiceGrpc.newStub(getChannel()).eventStream(responseObserver);
- requestObserverRef.set(requestObserver);
-
- // Send initial request — include any pending ACKs from a previous broken stream
- List carryOverAcks;
- synchronized (pendingAcks) {
- carryOverAcks = new ArrayList<>(pendingAcks);
- }
- if (!carryOverAcks.isEmpty()) {
- log.info(
- LogCategory.GRPC,
- "CarryOverAcks",
- "Sending %d pending ACKs from previous stream session",
- carryOverAcks.size());
- }
- log.debug(LogCategory.GRPC, "Init", "Sending initial event stream request...");
- requestObserver.onNext(
- EventStreamRequest.newBuilder()
- .setEventCount(BATCH_SIZE)
- .addAllAckEventIds(carryOverAcks)
- .build());
- if (!carryOverAcks.isEmpty()) {
- synchronized (pendingAcks) {
- pendingAcks.removeAll(carryOverAcks);
- }
- }
-
- awaitStreamWithHungDetection(latch);
-
- var error = errorRef.get();
- if (error != null) {
- throw new RuntimeException("Stream error", error);
- }
- }
-
- // ---------------------------------------------------------------------------
- // Request & ACK management
- // ---------------------------------------------------------------------------
-
- /**
- * Send the next request on the stream, draining pendingAcks into the request. If the send fails,
- * the ACKs remain in pendingAcks for the next attempt or reconnection.
- */
- private void sendNextRequest() {
- var observer = requestObserverRef.get();
- if (observer == null) {
- log.warn(LogCategory.GRPC, "RequestFailed", "Cannot send next request - no active observer");
- return;
- }
-
- List acksToSend;
- synchronized (pendingAcks) {
- acksToSend = new ArrayList<>(pendingAcks);
- }
-
- try {
- var request =
- EventStreamRequest.newBuilder()
- .setEventCount(BATCH_SIZE)
- .addAllAckEventIds(acksToSend)
- .build();
- observer.onNext(request);
-
- if (!acksToSend.isEmpty()) {
- synchronized (pendingAcks) {
- pendingAcks.removeAll(acksToSend);
- }
- log.debug(
- LogCategory.GRPC,
- "AckSent",
- "Sent ACK for %d events, requesting next batch",
- acksToSend.size());
- }
- } catch (Exception e) {
- log.error(
- LogCategory.GRPC,
- "RequestFailed",
- "Failed to send next event stream request (keeping %d pending ACKs): %s",
- acksToSend.size(),
- e.getMessage());
- }
- }
-
- // ---------------------------------------------------------------------------
- // Event processing
- // ---------------------------------------------------------------------------
-
- /** Process a batch of events, adding successful ACK IDs to the pending buffer. */
- private void processBatch(List events) {
- long batchStart = System.currentTimeMillis();
- int successCount = 0;
-
- for (Event event : events) {
- String eventId = getEventId(event);
- if (processEvent(event)) {
- synchronized (pendingAcks) {
- pendingAcks.add(eventId);
- }
- successCount++;
- eventsProcessed.incrementAndGet();
- } else {
- eventsFailed.incrementAndGet();
- log.warn(
- LogCategory.GRPC,
- "EventNotAcked",
- "Event %s NOT acknowledged - will be redelivered",
- eventId);
- }
- }
-
- long elapsed = System.currentTimeMillis() - batchStart;
- if (successCount > 0 && (elapsed / successCount) > 1000) {
- log.warn(
- LogCategory.GRPC,
- "SlowBatch",
- "Event batch completed %d events in %dms, avg %dms per event",
- successCount,
- elapsed,
- elapsed / successCount);
- }
- }
-
- /**
- * Process a single event by dispatching to the plugin. Returns true if successfully processed.
- */
- private boolean processEvent(Event event) {
- try {
- if (!plugin.isRunning()) {
- log.debug(
- LogCategory.GRPC,
- "PluginNotRunning",
- "Plugin is not running, skipping event processing");
- return false;
- }
-
- switch (event.getEntityCase()) {
- case AGENT_CALL:
- log.debug(
- LogCategory.GRPC,
- "EventProcessed",
- "Received agent call event %d - %s",
- event.getAgentCall().getCallSid(),
- event.getAgentCall().getCallType());
- plugin.handleAgentCall(event.getAgentCall());
- break;
- case AGENT_RESPONSE:
- log.debug(
- LogCategory.GRPC,
- "EventProcessed",
- "Received agent response event %s",
- event.getAgentResponse().getAgentCallResponseSid());
- plugin.handleAgentResponse(event.getAgentResponse());
- break;
- case TELEPHONY_RESULT:
- log.debug(
- LogCategory.GRPC,
- "EventProcessed",
- "Received telephony result event %d - %s",
- event.getTelephonyResult().getCallSid(),
- event.getTelephonyResult().getCallType());
- plugin.handleTelephonyResult(event.getTelephonyResult());
- break;
- case TASK:
- log.debug(
- LogCategory.GRPC,
- "EventProcessed",
- "Received task event %s",
- event.getTask().getTaskSid());
- plugin.handleTask(event.getTask());
- break;
- case TRANSFER_INSTANCE:
- log.debug(
- LogCategory.GRPC,
- "EventProcessed",
- "Received transfer instance event %s",
- event.getTransferInstance().getTransferInstanceId());
- plugin.handleTransferInstance(event.getTransferInstance());
- break;
- case CALL_RECORDING:
- log.debug(
- LogCategory.GRPC,
- "EventProcessed",
- "Received call recording event %s",
- event.getCallRecording().getRecordingId());
- plugin.handleCallRecording(event.getCallRecording());
- break;
- default:
- log.warn(
- LogCategory.GRPC, "UnknownEvent", "Unknown event type: %s", event.getEntityCase());
- break;
- }
-
- return true;
- } catch (Exception e) {
- log.error(
- LogCategory.GRPC,
- "EventProcessingError",
- "Failed to process event: %s",
- e.getMessage(),
- e);
- return false;
- }
- }
-
- /**
- * Extract the server-assigned entity ID for ACK purposes. The server sets exile_entity_id on each
- * Event from the DB's entity_id, which may be a composite key (e.g. "call_type,call_sid" for
- * telephony). We must echo this exact value back for the ACK to match.
- */
- private String getEventId(Event event) {
- String entityId = event.getExileEntityId();
- if (entityId == null || entityId.isEmpty()) {
- log.warn(
- LogCategory.GRPC,
- "MissingEntityId",
- "Event has no exile_entity_id, cannot ACK. Event type: %s",
- event.getEntityCase());
- return "unknown";
- }
- return entityId;
- }
-
- // ---------------------------------------------------------------------------
- // Lifecycle
- // ---------------------------------------------------------------------------
-
- @Override
- public void stop() {
- log.info(
- LogCategory.GRPC,
- "Stopping",
- "Stopping GateClientEventStream (total attempts: %d, successful: %d, events: %d/%d)",
- totalReconnectionAttempts.get(),
- successfulReconnections.get(),
- eventsProcessed.get(),
- eventsFailed.get());
-
- synchronized (pendingAcks) {
- if (!pendingAcks.isEmpty()) {
- log.warn(
- LogCategory.GRPC,
- "UnsentAcks",
- "Shutting down with %d un-sent ACKs (these events will be redelivered): %s",
- pendingAcks.size(),
- pendingAcks);
- }
- }
-
- var observer = requestObserverRef.get();
- if (observer != null) {
- try {
- observer.onCompleted();
- } catch (Exception e) {
- log.debug(LogCategory.GRPC, "CloseError", "Error closing stream: %s", e.getMessage());
- }
- }
-
- doStop();
- log.info(LogCategory.GRPC, "Stopped", "GateClientEventStream stopped");
- }
-
- @PreDestroy
- public void destroy() {
- stop();
- }
-
- public Map getStreamStatus() {
- Map status = buildStreamStatus();
- status.put("eventsProcessed", eventsProcessed.get());
- status.put("eventsFailed", eventsFailed.get());
- synchronized (pendingAcks) {
- status.put("pendingAckCount", pendingAcks.size());
- }
- return status;
- }
-}
diff --git a/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientJobQueue.java b/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientJobQueue.java
deleted file mode 100644
index b9b2784..0000000
--- a/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientJobQueue.java
+++ /dev/null
@@ -1,364 +0,0 @@
-/*
- * (C) 2017-2026 TCN Inc. All rights reserved.
- *
- * Licensed 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
- *
- * https://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.
- *
- */
-package com.tcn.exile.gateclients.v2;
-
-import build.buf.gen.tcnapi.exile.gate.v2.GateServiceGrpc;
-import build.buf.gen.tcnapi.exile.gate.v2.JobQueueStreamRequest;
-import build.buf.gen.tcnapi.exile.gate.v2.JobQueueStreamResponse;
-import build.buf.gen.tcnapi.exile.gate.v2.StreamJobsResponse;
-import build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest;
-import com.tcn.exile.config.Config;
-import com.tcn.exile.gateclients.UnconfiguredException;
-import com.tcn.exile.log.LogCategory;
-import com.tcn.exile.log.StructuredLogger;
-import com.tcn.exile.plugin.PluginInterface;
-import io.grpc.stub.StreamObserver;
-import jakarta.annotation.PreDestroy;
-import java.time.Instant;
-import java.util.Map;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.atomic.AtomicReference;
-
-/** Bidirectional job streaming with acknowledgment using the JobQueueStream API. */
-public class GateClientJobQueue extends GateClientAbstract {
- private static final StructuredLogger log = new StructuredLogger(GateClientJobQueue.class);
- private static final int DEFAULT_TIMEOUT_SECONDS = 300;
- private static final String KEEPALIVE_JOB_ID = "keepalive";
-
- private final PluginInterface plugin;
- private final AtomicLong jobsProcessed = new AtomicLong(0);
- private final AtomicLong jobsFailed = new AtomicLong(0);
-
- // Stream observer for sending ACKs
- private final AtomicReference> requestObserverRef =
- new AtomicReference<>();
-
- public GateClientJobQueue(String tenant, Config currentConfig, PluginInterface plugin) {
- super(tenant, currentConfig);
- this.plugin = plugin;
- }
-
- @Override
- protected String getStreamName() {
- return "JobQueue";
- }
-
- @Override
- protected void onStreamDisconnected() {
- requestObserverRef.set(null);
- }
-
- @Override
- protected void runStream()
- throws UnconfiguredException, InterruptedException, HungConnectionException {
- var latch = new CountDownLatch(1);
- var errorRef = new AtomicReference();
- var firstResponseReceived = new AtomicBoolean(false);
-
- var responseObserver =
- new StreamObserver() {
- @Override
- public void onNext(JobQueueStreamResponse response) {
- lastMessageTime.set(Instant.now());
-
- if (firstResponseReceived.compareAndSet(false, true)) {
- onConnectionEstablished();
- }
-
- if (!response.hasJob()) {
- log.debug(LogCategory.GRPC, "Heartbeat", "Received heartbeat from server");
- return;
- }
-
- var job = response.getJob();
- String jobId = job.getJobId();
-
- // Handle keepalive — must ACK to register with presence store
- if (KEEPALIVE_JOB_ID.equals(jobId)) {
- log.debug(
- LogCategory.GRPC, "Keepalive", "Received keepalive, sending ACK to register");
- sendAck(KEEPALIVE_JOB_ID);
- if (job.hasInfo()) {
- try {
- plugin.info(KEEPALIVE_JOB_ID, job.getInfo());
- } catch (Exception e) {
- log.warn(
- LogCategory.GRPC,
- "KeepaliveInfo",
- "Failed to dispatch info on keepalive: %s",
- e.getMessage());
- }
- }
- return;
- }
-
- log.debug(
- LogCategory.GRPC,
- "JobReceived",
- "Received job: %s (type: %s)",
- jobId,
- getJobType(job));
-
- if (processJob(job)) {
- sendAck(jobId);
- jobsProcessed.incrementAndGet();
- } else {
- jobsFailed.incrementAndGet();
- log.warn(
- LogCategory.GRPC,
- "JobNotAcked",
- "Job %s NOT acknowledged - will be redelivered to another client",
- jobId);
- }
- }
-
- @Override
- public void onError(Throwable t) {
- log.warn(LogCategory.GRPC, "StreamError", "Job queue stream error: %s", t.getMessage());
- errorRef.set(t);
- latch.countDown();
- }
-
- @Override
- public void onCompleted() {
- log.info(LogCategory.GRPC, "StreamCompleted", "Job queue stream completed by server");
- latch.countDown();
- }
- };
-
- // Open bidirectional stream
- var requestObserver = GateServiceGrpc.newStub(getChannel()).jobQueueStream(responseObserver);
- requestObserverRef.set(requestObserver);
-
- // Send initial keepalive to register with server
- log.debug(LogCategory.GRPC, "Init", "Sending initial keepalive to job queue...");
- requestObserver.onNext(JobQueueStreamRequest.newBuilder().setJobId(KEEPALIVE_JOB_ID).build());
-
- awaitStreamWithHungDetection(latch);
-
- var error = errorRef.get();
- if (error != null) {
- throw new RuntimeException("Stream error", error);
- }
- }
-
- // ---------------------------------------------------------------------------
- // ACK management
- // ---------------------------------------------------------------------------
-
- /** Send acknowledgment for a job. */
- private void sendAck(String jobId) {
- var observer = requestObserverRef.get();
- if (observer == null) {
- log.warn(
- LogCategory.GRPC, "AckFailed", "Cannot send ACK for job %s - no active observer", jobId);
- return;
- }
- try {
- observer.onNext(JobQueueStreamRequest.newBuilder().setJobId(jobId).build());
- log.debug(LogCategory.GRPC, "AckSent", "Sent ACK for job: %s", jobId);
- } catch (Exception e) {
- log.error(
- LogCategory.GRPC,
- "AckFailed",
- "Failed to send ACK for job %s: %s",
- jobId,
- e.getMessage());
- }
- }
-
- // ---------------------------------------------------------------------------
- // Job processing
- // ---------------------------------------------------------------------------
-
- /** Process a job by dispatching to the plugin. Returns true if successfully processed. */
- private boolean processJob(StreamJobsResponse value) {
- long jobStartTime = System.currentTimeMillis();
-
- try {
- boolean adminJob = isAdminJob(value);
- if (!adminJob && !plugin.isRunning()) {
- log.warn(
- LogCategory.GRPC,
- "JobRejected",
- "Skipping job %s because database is unavailable (only admin jobs can run)",
- value.getJobId());
- submitJobError(value.getJobId(), "Database unavailable; only admin jobs can run");
- return false;
- }
-
- if (value.hasListPools()) {
- plugin.listPools(value.getJobId(), value.getListPools());
- } else if (value.hasGetPoolStatus()) {
- plugin.getPoolStatus(value.getJobId(), value.getGetPoolStatus());
- } else if (value.hasGetPoolRecords()) {
- plugin.getPoolRecords(value.getJobId(), value.getGetPoolRecords());
- } else if (value.hasSearchRecords()) {
- plugin.searchRecords(value.getJobId(), value.getSearchRecords());
- } else if (value.hasGetRecordFields()) {
- plugin.readFields(value.getJobId(), value.getGetRecordFields());
- } else if (value.hasSetRecordFields()) {
- plugin.writeFields(value.getJobId(), value.getSetRecordFields());
- } else if (value.hasCreatePayment()) {
- plugin.createPayment(value.getJobId(), value.getCreatePayment());
- } else if (value.hasPopAccount()) {
- plugin.popAccount(value.getJobId(), value.getPopAccount());
- } else if (value.hasInfo()) {
- plugin.info(value.getJobId(), value.getInfo());
- } else if (value.hasShutdown()) {
- plugin.shutdown(value.getJobId(), value.getShutdown());
- } else if (value.hasLogging()) {
- plugin.logger(value.getJobId(), value.getLogging());
- } else if (value.hasExecuteLogic()) {
- plugin.executeLogic(value.getJobId(), value.getExecuteLogic());
- } else if (value.hasDiagnostics()) {
- plugin.runDiagnostics(value.getJobId(), value.getDiagnostics());
- } else if (value.hasListTenantLogs()) {
- plugin.listTenantLogs(value.getJobId(), value.getListTenantLogs());
- } else if (value.hasSetLogLevel()) {
- plugin.setLogLevel(value.getJobId(), value.getSetLogLevel());
- } else {
- log.error(
- LogCategory.GRPC, "UnknownJobType", "Unknown job type: %s", value.getUnknownFields());
- }
-
- long jobDuration = System.currentTimeMillis() - jobStartTime;
- log.debug(
- LogCategory.GRPC,
- "JobCompleted",
- "Processed job %s in %d ms",
- value.getJobId(),
- jobDuration);
- return true;
-
- } catch (UnconfiguredException e) {
- long jobDuration = System.currentTimeMillis() - jobStartTime;
- log.error(
- LogCategory.GRPC,
- "JobHandlingError",
- "Error while handling job: %s (took %d ms)",
- value.getJobId(),
- jobDuration,
- e);
- return false;
- } catch (Exception e) {
- long jobDuration = System.currentTimeMillis() - jobStartTime;
- log.error(
- LogCategory.GRPC,
- "UnexpectedJobError",
- "Unexpected error while handling job: %s (took %d ms)",
- value.getJobId(),
- jobDuration,
- e);
- return false;
- }
- }
-
- private String getJobType(StreamJobsResponse job) {
- if (job.hasListPools()) return "listPools";
- if (job.hasGetPoolStatus()) return "getPoolStatus";
- if (job.hasGetPoolRecords()) return "getPoolRecords";
- if (job.hasSearchRecords()) return "searchRecords";
- if (job.hasGetRecordFields()) return "getRecordFields";
- if (job.hasSetRecordFields()) return "setRecordFields";
- if (job.hasCreatePayment()) return "createPayment";
- if (job.hasPopAccount()) return "popAccount";
- if (job.hasInfo()) return "info";
- if (job.hasShutdown()) return "shutdown";
- if (job.hasLogging()) return "logging";
- if (job.hasExecuteLogic()) return "executeLogic";
- if (job.hasDiagnostics()) return "diagnostics";
- if (job.hasListTenantLogs()) return "listTenantLogs";
- if (job.hasSetLogLevel()) return "setLogLevel";
- return "unknown";
- }
-
- private boolean isAdminJob(StreamJobsResponse value) {
- return value.hasDiagnostics()
- || value.hasListTenantLogs()
- || value.hasSetLogLevel()
- || value.hasShutdown()
- || value.hasInfo();
- }
-
- private void submitJobError(String jobId, String message) {
- try {
- SubmitJobResultsRequest request =
- SubmitJobResultsRequest.newBuilder()
- .setJobId(jobId)
- .setEndOfTransmission(true)
- .setErrorResult(
- SubmitJobResultsRequest.ErrorResult.newBuilder().setMessage(message).build())
- .build();
-
- GateServiceGrpc.newBlockingStub(getChannel())
- .withDeadlineAfter(DEFAULT_TIMEOUT_SECONDS, TimeUnit.SECONDS)
- .withWaitForReady()
- .submitJobResults(request);
- } catch (Exception e) {
- log.error(
- LogCategory.GRPC,
- "SubmitJobErrorFailed",
- "Failed to submit error for job %s: %s",
- jobId,
- e.getMessage());
- }
- }
-
- // ---------------------------------------------------------------------------
- // Lifecycle
- // ---------------------------------------------------------------------------
-
- @Override
- public void stop() {
- log.info(
- LogCategory.GRPC,
- "Stopping",
- "Stopping GateClientJobQueue (total attempts: %d, successful: %d, jobs: %d/%d)",
- totalReconnectionAttempts.get(),
- successfulReconnections.get(),
- jobsProcessed.get(),
- jobsFailed.get());
-
- var observer = requestObserverRef.get();
- if (observer != null) {
- try {
- observer.onCompleted();
- } catch (Exception e) {
- log.debug(LogCategory.GRPC, "CloseError", "Error closing stream: %s", e.getMessage());
- }
- }
-
- doStop();
- log.info(LogCategory.GRPC, "Stopped", "GateClientJobQueue stopped");
- }
-
- @PreDestroy
- public void destroy() {
- stop();
- }
-
- public Map getStreamStatus() {
- Map status = buildStreamStatus();
- status.put("jobsProcessed", jobsProcessed.get());
- status.put("jobsFailed", jobsFailed.get());
- return status;
- }
-}
diff --git a/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientJobStream.java b/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientJobStream.java
deleted file mode 100644
index 3ea6f87..0000000
--- a/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientJobStream.java
+++ /dev/null
@@ -1,351 +0,0 @@
-/*
- * (C) 2017-2025 TCN Inc. All rights reserved.
- *
- * Licensed 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
- *
- * https://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.
- *
- */
-package com.tcn.exile.gateclients.v2;
-
-import build.buf.gen.tcnapi.exile.gate.v2.GateServiceGrpc;
-import build.buf.gen.tcnapi.exile.gate.v2.StreamJobsRequest;
-import build.buf.gen.tcnapi.exile.gate.v2.StreamJobsResponse;
-import build.buf.gen.tcnapi.exile.gate.v2.SubmitJobResultsRequest;
-import com.tcn.exile.config.Config;
-import com.tcn.exile.gateclients.UnconfiguredException;
-import com.tcn.exile.log.LogCategory;
-import com.tcn.exile.log.StructuredLogger;
-import com.tcn.exile.plugin.PluginInterface;
-import io.grpc.ConnectivityState;
-import io.grpc.ManagedChannel;
-import io.grpc.stub.StreamObserver;
-import jakarta.annotation.PreDestroy;
-import java.time.Duration;
-import java.time.Instant;
-import java.time.temporal.ChronoUnit;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.ExecutorCompletionService;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.atomic.AtomicReference;
-
-/**
- * @deprecated Use {@link GateClientJobQueue} instead. This class uses the deprecated StreamJobs
- * server-streaming API which has been replaced by the JobQueueStream bidirectional API with
- * acknowledgment support.
- */
-@Deprecated
-public class GateClientJobStream extends GateClientAbstract
- implements StreamObserver {
- private static final StructuredLogger log = new StructuredLogger(GateClientJobStream.class);
- private static final int DEFAULT_TIMEOUT_SECONDS = 300;
-
- private final PluginInterface plugin;
- private final AtomicBoolean establishedForCurrentAttempt = new AtomicBoolean(false);
- private final AtomicReference lastMessageTime = new AtomicReference<>();
-
- // Connection timing tracking
- private final AtomicReference lastDisconnectTime = new AtomicReference<>();
- private final AtomicReference reconnectionStartTime = new AtomicReference<>();
- private final AtomicReference connectionEstablishedTime = new AtomicReference<>();
- private final AtomicLong totalReconnectionAttempts = new AtomicLong(0);
- private final AtomicLong successfulReconnections = new AtomicLong(0);
- private final AtomicReference lastErrorType = new AtomicReference<>();
- private final AtomicLong consecutiveFailures = new AtomicLong(0);
- private final AtomicBoolean isRunning = new AtomicBoolean(false);
-
- public GateClientJobStream(String tenant, Config currentConfig, PluginInterface plugin) {
- super(tenant, currentConfig);
- this.plugin = plugin;
- }
-
- private boolean channelIsDead(ConnectivityState state) {
- return state.compareTo(ConnectivityState.TRANSIENT_FAILURE) == 0
- || state.compareTo(ConnectivityState.SHUTDOWN) == 0;
- }
-
- private boolean lastJobReceivedTooLongAgo(Instant lastMessageTime) {
- return lastMessageTime != null
- && lastMessageTime.isBefore(Instant.now().minus(45, ChronoUnit.SECONDS));
- }
-
- private void blowupIfOurConnectionIsHung(ManagedChannel channel) throws Exception {
- var state = channel.getState(false);
- if (channelIsDead(state)) {
- throw new Exception("JobStream channel is in state " + state.toString());
- }
- var lastJobTime = lastMessageTime.get();
- var startOfStream = connectionEstablishedTime.get();
-
- // if we haven't received a job ever, then test when we started the stream
- if (lastJobTime == null && lastJobReceivedTooLongAgo(startOfStream)) {
- throw new Exception(
- "JobStream never received any messages since start time at: "
- + startOfStream.toString()
- + " connection is hung");
- }
- if (lastJobReceivedTooLongAgo(lastJobTime)) {
- throw new Exception(
- "JobStream received last job too long ago at: "
- + lastJobTime.toString()
- + " connection is hung");
- }
- }
-
- public void start() {
- if (isUnconfigured()) {
- log.warn(LogCategory.GRPC, "NOOP", "JobStream is unconfigured, cannot stream jobs");
- return;
- }
-
- ExecutorService executorService = Executors.newVirtualThreadPerTaskExecutor();
- ExecutorCompletionService completionService =
- new ExecutorCompletionService<>(executorService);
-
- try {
- log.debug(LogCategory.GRPC, "Init", "JobStream task started, checking configuration status");
-
- log.debug(LogCategory.GRPC, "Start", "Starting JobStream");
- reconnectionStartTime.set(Instant.now());
- ManagedChannel channel = getChannel();
-
- var client =
- GateServiceGrpc.newBlockingStub(channel)
- .withWaitForReady()
- .streamJobs(StreamJobsRequest.newBuilder().build());
-
- connectionEstablishedTime.set(Instant.now());
- successfulReconnections.incrementAndGet();
- isRunning.set(true);
- consecutiveFailures.set(0);
- lastErrorType.set(null);
-
- log.info(
- LogCategory.GRPC,
- "ConnectionEstablished",
- "Job stream connection took {}",
- Duration.between(reconnectionStartTime.get(), connectionEstablishedTime.get()));
-
- completionService.submit(
- () -> {
- client.forEachRemaining(this::onNext);
- return null;
- });
- completionService.submit(
- () -> {
- while (isRunning.get()) {
- Thread.sleep(45000);
- blowupIfOurConnectionIsHung(channel);
- }
- return null;
- });
- // blow up or wait
- completionService.take();
-
- } catch (Exception e) {
- log.error(LogCategory.GRPC, "JobStream", "error streaming jobs from server: {}", e);
- lastErrorType.set(e.getClass().getSimpleName());
- if (connectionEstablishedTime.get() == null) {
- consecutiveFailures.incrementAndGet();
- }
- } finally {
- totalReconnectionAttempts.incrementAndGet();
- lastDisconnectTime.set(Instant.now());
- isRunning.set(false);
- log.debug(LogCategory.GRPC, "Complete", "Job stream done");
-
- executorService.shutdownNow();
- }
- }
-
- @Override
- public void onNext(StreamJobsResponse value) {
- long jobStartTime = System.currentTimeMillis();
- log.debug(LogCategory.GRPC, "JobReceived", "Received job: %s", value.getJobId());
- lastMessageTime.set(Instant.now());
-
- try {
- boolean adminJob = isAdminJob(value);
- if (!adminJob && !plugin.isRunning()) {
- log.warn(
- LogCategory.GRPC,
- "JobRejected",
- "Skipping job %s because database is unavailable (only admin jobs can run)",
- value.getJobId());
- submitJobError(value.getJobId(), "Database unavailable; only admin jobs can run");
- return;
- }
-
- if (value.hasListPools()) {
- plugin.listPools(value.getJobId(), value.getListPools());
- } else if (value.hasGetPoolStatus()) {
- plugin.getPoolStatus(value.getJobId(), value.getGetPoolStatus());
- } else if (value.hasGetPoolRecords()) {
- plugin.getPoolRecords(value.getJobId(), value.getGetPoolRecords());
- } else if (value.hasSearchRecords()) {
- plugin.searchRecords(value.getJobId(), value.getSearchRecords());
- } else if (value.hasGetRecordFields()) {
- plugin.readFields(value.getJobId(), value.getGetRecordFields());
- } else if (value.hasSetRecordFields()) {
- plugin.writeFields(value.getJobId(), value.getSetRecordFields());
- } else if (value.hasCreatePayment()) {
- plugin.createPayment(value.getJobId(), value.getCreatePayment());
- } else if (value.hasPopAccount()) {
- plugin.popAccount(value.getJobId(), value.getPopAccount());
- } else if (value.hasInfo()) {
- plugin.info(value.getJobId(), value.getInfo());
- } else if (value.hasShutdown()) {
- plugin.shutdown(value.getJobId(), value.getShutdown());
- } else if (value.hasLogging()) {
- plugin.logger(value.getJobId(), value.getLogging());
- } else if (value.hasExecuteLogic()) {
- plugin.executeLogic(value.getJobId(), value.getExecuteLogic());
- } else if (value.hasDiagnostics()) {
- plugin.runDiagnostics(value.getJobId(), value.getDiagnostics());
- } else if (value.hasListTenantLogs()) {
- plugin.listTenantLogs(value.getJobId(), value.getListTenantLogs());
- } else if (value.hasSetLogLevel()) {
- plugin.setLogLevel(value.getJobId(), value.getSetLogLevel());
- } else {
- log.error(
- LogCategory.GRPC, "UnknownJobType", "Unknown job type: %s", value.getUnknownFields());
- }
- } catch (UnconfiguredException e) {
- long jobDuration = System.currentTimeMillis() - jobStartTime;
- log.error(
- LogCategory.GRPC,
- "JobHandlingError",
- "Error while handling job: %s (took %d ms)",
- value.getJobId(),
- jobDuration,
- e);
- } catch (Exception e) {
- long jobDuration = System.currentTimeMillis() - jobStartTime;
- log.error(
- LogCategory.GRPC,
- "UnexpectedJobError",
- "Unexpected error while handling job: %s (took %d ms)",
- value.getJobId(),
- jobDuration,
- e);
- }
- }
-
- @Override
- public void onError(Throwable t) {
- log.error(LogCategory.GRPC, "JobStreamError", "onError received: {}", t);
- }
-
- @Override
- public void onCompleted() {
- Instant disconnectTime = Instant.now();
- lastDisconnectTime.set(disconnectTime);
- lastMessageTime.set(disconnectTime);
-
- // Calculate connection uptime if we have connection establishment time
- Instant connectionTime = connectionEstablishedTime.get();
- String uptimeInfo = "";
- if (connectionTime != null) {
- Duration uptime = Duration.between(connectionTime, disconnectTime);
- uptimeInfo =
- String.format(" (connection was up for %.3f seconds)", uptime.toMillis() / 1000.0);
- }
-
- log.info(
- LogCategory.GRPC,
- "StreamCompleted",
- "Job stream onCompleted: Server closed the stream gracefully%s (total attempts: %d, successful: %d)",
- uptimeInfo,
- totalReconnectionAttempts.get(),
- successfulReconnections.get());
- }
-
- public void stop() {
- log.info(
- LogCategory.GRPC,
- "Stopping",
- "Stopping GateClientJobStream (total attempts: %d, successful: %d)",
- totalReconnectionAttempts.get(),
- successfulReconnections.get());
-
- shutdown();
- log.info(LogCategory.GRPC, "GateClientJobStreamStopped", "GateClientJobStream stopped");
- }
-
- private boolean isAdminJob(StreamJobsResponse value) {
- return value.hasDiagnostics()
- || value.hasListTenantLogs()
- || value.hasSetLogLevel()
- || value.hasShutdown()
- || value.hasInfo();
- }
-
- private void submitJobError(String jobId, String message) {
- try {
- SubmitJobResultsRequest request =
- SubmitJobResultsRequest.newBuilder()
- .setJobId(jobId)
- .setEndOfTransmission(true)
- .setErrorResult(
- SubmitJobResultsRequest.ErrorResult.newBuilder().setMessage(message).build())
- .build();
-
- GateServiceGrpc.newBlockingStub(getChannel())
- .withDeadlineAfter(DEFAULT_TIMEOUT_SECONDS, TimeUnit.SECONDS)
- .withWaitForReady()
- .submitJobResults(request);
- } catch (Exception e) {
- log.error(
- LogCategory.GRPC,
- "SubmitJobErrorFailed",
- "Failed to submit error for job %s: %s",
- jobId,
- e.getMessage());
- }
- }
-
- @PreDestroy
- public void destroy() {
- log.info(
- LogCategory.GRPC,
- "GateClientJobStream@PreDestroyCalled",
- "GateClientJobStream @PreDestroy called");
- stop();
- }
-
- public Map getStreamStatus() {
- // Add timing information to status
- Instant lastDisconnect = lastDisconnectTime.get();
- Instant connectionEstablished = connectionEstablishedTime.get();
- Instant reconnectStart = reconnectionStartTime.get();
- Instant lastMessage = lastMessageTime.get();
-
- Map status = new HashMap<>();
- status.put("isRunning", isRunning.get());
- status.put("totalReconnectionAttempts", totalReconnectionAttempts.get());
- status.put("successfulReconnections", successfulReconnections.get());
- status.put("consecutiveFailures", consecutiveFailures.get());
- status.put("lastDisconnectTime", lastDisconnect != null ? lastDisconnect.toString() : null);
- status.put(
- "connectionEstablishedTime",
- connectionEstablished != null ? connectionEstablished.toString() : null);
- status.put("reconnectionStartTime", reconnectStart != null ? reconnectStart.toString() : null);
- status.put("lastErrorType", lastErrorType.get());
- status.put("lastMessageTime", lastMessage != null ? lastMessage.toString() : null);
-
- return status;
- }
-}
diff --git a/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientPollEvents.java b/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientPollEvents.java
deleted file mode 100644
index c955370..0000000
--- a/core/src/main/java/com/tcn/exile/gateclients/v2/GateClientPollEvents.java
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- * (C) 2017-2025 TCN Inc. All rights reserved.
- *
- * Licensed 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
- *
- * https://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.
- *
- */
-package com.tcn.exile.gateclients.v2;
-
-import build.buf.gen.tcnapi.exile.gate.v2.GateServiceGrpc;
-import build.buf.gen.tcnapi.exile.gate.v2.PollEventsRequest;
-import com.tcn.exile.config.Config;
-import com.tcn.exile.gateclients.UnconfiguredException;
-import com.tcn.exile.plugin.PluginInterface;
-import io.grpc.StatusRuntimeException;
-import java.util.concurrent.TimeUnit;
-
-/**
- * @deprecated Use {@link GateClientEventStream} instead. This class uses the deprecated PollEvents
- * unary API which has been replaced by the EventStream bidirectional API with acknowledgment
- * support.
- */
-@Deprecated
-public class GateClientPollEvents extends GateClientAbstract {
- protected static final org.slf4j.Logger log =
- org.slf4j.LoggerFactory.getLogger(GateClientPollEvents.class);
-
- PluginInterface plugin;
-
- public GateClientPollEvents(String tenant, Config currentConfig, PluginInterface plugin) {
- super(tenant, currentConfig);
- this.plugin = plugin;
- }
-
- // Batch size for polling events - Gate supports up to 1000
- private static final int BATCH_SIZE = 100;
-
- @Override
- public void start() {
- try {
- if (isUnconfigured()) {
- log.debug("Tenant: {} - Configuration not set, skipping poll events", tenant);
- return;
- }
- if (!plugin.isRunning()) {
- log.debug(
- "Tenant: {} - Plugin is not running (possibly due to database disconnection), skipping poll events",
- tenant);
- return;
- }
-
- int eventsReceived;
- int totalProcessed = 0;
- long cycleStart = System.currentTimeMillis();
-
- // Keep polling as long as we receive a full batch (indicating more events may
- // be waiting)
- do {
- var client =
- GateServiceGrpc.newBlockingStub(getChannel())
- .withDeadlineAfter(300, TimeUnit.SECONDS)
- .withWaitForReady();
- var response =
- client.pollEvents(PollEventsRequest.newBuilder().setEventCount(BATCH_SIZE).build());
-
- eventsReceived = response.getEventsCount();
-
- if (eventsReceived == 0) {
- if (totalProcessed == 0) {
- log.debug(
- "Tenant: {} - Poll events request completed successfully but no events were received",
- tenant);
- }
- break;
- }
-
- long batchStart = System.currentTimeMillis();
- response
- .getEventsList()
- .forEach(
- event -> {
- if (event.hasAgentCall()) {
- log.debug(
- "Tenant: {} - Received agent call event {} - {}",
- tenant,
- event.getAgentCall().getCallSid(),
- event.getAgentCall().getCallType());
- plugin.handleAgentCall(event.getAgentCall());
- }
- if (event.hasAgentResponse()) {
- log.debug(
- "Tenant: {} - Received agent response event {}",
- tenant,
- event.getAgentResponse().getAgentCallResponseSid());
- plugin.handleAgentResponse(event.getAgentResponse());
- }
-
- if (event.hasTelephonyResult()) {
- log.debug(
- "Tenant: {} - Received telephony result event {} - {}",
- tenant,
- event.getTelephonyResult().getCallSid(),
- event.getTelephonyResult().getCallType());
- plugin.handleTelephonyResult(event.getTelephonyResult());
- }
-
- if (event.hasTask()) {
- log.debug(
- "Tenant: {} - Received task event {}",
- tenant,
- event.getTask().getTaskSid());
- plugin.handleTask(event.getTask());
- }
-
- if (event.hasTransferInstance()) {
- log.debug(
- "Tenant: {} - Received transfer instance event {}",
- tenant,
- event.getTransferInstance().getTransferInstanceId());
- plugin.handleTransferInstance(event.getTransferInstance());
- }
-
- if (event.hasCallRecording()) {
- log.debug(
- "Tenant: {} - Received call recording event {}",
- tenant,
- event.getCallRecording().getRecordingId());
- plugin.handleCallRecording(event.getCallRecording());
- }
- });
-
- long batchEnd = System.currentTimeMillis();
- totalProcessed += eventsReceived;
-
- // Warn if individual batch processing is slow
- if (eventsReceived > 0) {
- long avg = (batchEnd - batchStart) / eventsReceived;
- if (avg > 1000) {
- log.warn(
- "Tenant: {} - Poll events batch completed {} events in {}ms, average time per event: {}ms, this is long",
- tenant,
- eventsReceived,
- batchEnd - batchStart,
- avg);
- }
- }
-
- } while (eventsReceived >= BATCH_SIZE);
-
- // Log summary if we processed events across multiple batches
- if (totalProcessed > 0) {
- long cycleEnd = System.currentTimeMillis();
- log.info(
- "Tenant: {} - Poll cycle completed, processed {} total events in {}ms",
- tenant,
- totalProcessed,
- cycleEnd - cycleStart);
- }
-
- } catch (StatusRuntimeException e) {
- if (handleStatusRuntimeException(e)) {
- // Already handled in parent class method
- } else {
- log.error("Tenant: {} - Error in poll events: {}", tenant, e.getMessage());
- }
- } catch (UnconfiguredException e) {
- log.error("Tenant: {} - Error while getting client configuration {}", tenant, e.getMessage());
- } catch (Exception e) {
- log.error("Tenant: {} - Unexpected error in poll events", tenant, e);
- }
- }
-}
diff --git a/core/src/main/java/com/tcn/exile/handler/EventHandler.java b/core/src/main/java/com/tcn/exile/handler/EventHandler.java
new file mode 100644
index 0000000..745bd73
--- /dev/null
+++ b/core/src/main/java/com/tcn/exile/handler/EventHandler.java
@@ -0,0 +1,28 @@
+package com.tcn.exile.handler;
+
+import com.tcn.exile.model.event.*;
+
+/**
+ * Handles events dispatched by the gate server. Events are informational — the server only needs an
+ * acknowledgment, not a result.
+ *
+ *
If a method throws, the work item is nacked and will be redelivered.
+ *
+ *
Methods run on virtual threads — blocking I/O is fine.
+ *
+ *
Default implementations are no-ops. Override only what you need.
+ */
+public interface EventHandler {
+
+ default void onAgentCall(AgentCallEvent event) throws Exception {}
+
+ default void onTelephonyResult(TelephonyResultEvent event) throws Exception {}
+
+ default void onAgentResponse(AgentResponseEvent event) throws Exception {}
+
+ default void onTransferInstance(TransferInstanceEvent event) throws Exception {}
+
+ default void onCallRecording(CallRecordingEvent event) throws Exception {}
+
+ default void onTask(TaskEvent event) throws Exception {}
+}
diff --git a/core/src/main/java/com/tcn/exile/handler/JobHandler.java b/core/src/main/java/com/tcn/exile/handler/JobHandler.java
new file mode 100644
index 0000000..dd34eb4
--- /dev/null
+++ b/core/src/main/java/com/tcn/exile/handler/JobHandler.java
@@ -0,0 +1,95 @@
+package com.tcn.exile.handler;
+
+import com.tcn.exile.model.*;
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Handles jobs dispatched by the gate server. Each method receives plain Java parameters and
+ * returns plain Java types. Proto conversion is handled internally by the library.
+ *
+ *
Methods run on virtual threads — blocking I/O (JDBC, HTTP) is fine.
+ *
+ *
Default implementations throw {@link UnsupportedOperationException}. Integrations override
+ * only the jobs they handle and declare those as capabilities at registration.
+ */
+public interface JobHandler {
+
+ default List listPools() throws Exception {
+ throw new UnsupportedOperationException("listPools not implemented");
+ }
+
+ default Pool getPoolStatus(String poolId) throws Exception {
+ throw new UnsupportedOperationException("getPoolStatus not implemented");
+ }
+
+ default Page getPoolRecords(String poolId, String pageToken, int pageSize)
+ throws Exception {
+ throw new UnsupportedOperationException("getPoolRecords not implemented");
+ }
+
+ default Page searchRecords(List filters, String pageToken, int pageSize)
+ throws Exception {
+ throw new UnsupportedOperationException("searchRecords not implemented");
+ }
+
+ default List getRecordFields(String poolId, String recordId, List fieldNames)
+ throws Exception {
+ throw new UnsupportedOperationException("getRecordFields not implemented");
+ }
+
+ default boolean setRecordFields(String poolId, String recordId, List fields)
+ throws Exception {
+ throw new UnsupportedOperationException("setRecordFields not implemented");
+ }
+
+ default String createPayment(String poolId, String recordId, Map paymentData)
+ throws Exception {
+ throw new UnsupportedOperationException("createPayment not implemented");
+ }
+
+ default DataRecord popAccount(String poolId, String recordId) throws Exception {
+ throw new UnsupportedOperationException("popAccount not implemented");
+ }
+
+ default Map executeLogic(String logicName, Map parameters)
+ throws Exception {
+ throw new UnsupportedOperationException("executeLogic not implemented");
+ }
+
+ /** Return client info. Keys: appName, appVersion, plus any custom metadata. */
+ default Map info() throws Exception {
+ throw new UnsupportedOperationException("info not implemented");
+ }
+
+ default void shutdown(String reason) throws Exception {
+ throw new UnsupportedOperationException("shutdown not implemented");
+ }
+
+ default void processLog(String payload) throws Exception {
+ throw new UnsupportedOperationException("processLog not implemented");
+ }
+
+ /** Return system diagnostics as structured sections. */
+ default DiagnosticsInfo diagnostics() throws Exception {
+ throw new UnsupportedOperationException("diagnostics not implemented");
+ }
+
+ default Page listTenantLogs(
+ Instant startTime, Instant endTime, String pageToken, int pageSize) throws Exception {
+ throw new UnsupportedOperationException("listTenantLogs not implemented");
+ }
+
+ default void setLogLevel(String loggerName, String level) throws Exception {
+ throw new UnsupportedOperationException("setLogLevel not implemented");
+ }
+
+ record DiagnosticsInfo(
+ Map systemInfo,
+ Map runtimeInfo,
+ Map databaseInfo,
+ Map custom) {}
+
+ record LogEntry(Instant timestamp, String level, String logger, String message) {}
+}
diff --git a/core/src/main/java/com/tcn/exile/handler/Plugin.java b/core/src/main/java/com/tcn/exile/handler/Plugin.java
new file mode 100644
index 0000000..0718cb7
--- /dev/null
+++ b/core/src/main/java/com/tcn/exile/handler/Plugin.java
@@ -0,0 +1,38 @@
+package com.tcn.exile.handler;
+
+import com.tcn.exile.service.ConfigService;
+
+/**
+ * The integration point for CRM plugins. Implementations provide job handling, event handling, and
+ * config validation.
+ *
+ *
Extend {@link PluginBase} for default implementations of common operations (logs, diagnostics,
+ * info, shutdown, log level control). Only override the CRM-specific methods you need.
+ *
+ *
Lifecycle:
+ *
+ *
+ *
Config is polled from the gate
+ *
{@link #onConfig} is called — plugin validates and initializes resources
+ *
If {@code onConfig} returns {@code true}, the WorkStream opens
+ *
Jobs arrive → {@link JobHandler} methods are called
+ *
Events arrive → {@link EventHandler} methods are called
+ *
+ */
+public interface Plugin extends JobHandler, EventHandler {
+
+ /**
+ * Called when the gate returns a new or changed config. The plugin should validate the config
+ * payload and initialize its resources (database connections, HTTP clients, etc.).
+ *
+ *
Return {@code true} if the plugin is ready to handle work. The WorkStream opens only after
+ * the first {@code true} return. Return {@code false} to reject the config — the poller will
+ * retry on the next cycle.
+ */
+ boolean onConfig(ConfigService.ClientConfiguration config);
+
+ /** Human-readable plugin name for diagnostics. */
+ default String pluginName() {
+ return getClass().getSimpleName();
+ }
+}
diff --git a/core/src/main/java/com/tcn/exile/handler/PluginBase.java b/core/src/main/java/com/tcn/exile/handler/PluginBase.java
new file mode 100644
index 0000000..891063e
--- /dev/null
+++ b/core/src/main/java/com/tcn/exile/handler/PluginBase.java
@@ -0,0 +1,215 @@
+package com.tcn.exile.handler;
+
+import com.tcn.exile.memlogger.MemoryAppender;
+import com.tcn.exile.memlogger.MemoryAppenderInstance;
+import com.tcn.exile.model.Page;
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Base class for plugins that provides default implementations for common operations: log
+ * retrieval, log level control, diagnostics, info, shutdown, and remote logging.
+ *
+ *
Extend this class and override only the CRM-specific methods (pool/record operations, event
+ * handlers, config validation).
+ *
+ *