@uns-kit/api 3.0.36 → 3.0.37

package/dist/app.d.ts

@@ -10,6 +10,12 @@ type MountConfig = {
 };
 export default class App {
     private expressApplication;
+    private ownershipGate;
+    private readonly acceptedRequests;
+    private requestFailed;
+    setOwnershipGate(gate: () => boolean): void;
+    drainRequests(): Promise<void>;
+    stop(): Promise<void>;
     server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
     private port;
     router: Router;

package/dist/app.js

@@ -28,6 +28,24 @@ const buildSwaggerPath = (base, processName, instanceName) => {
 };
 export default class App {
     expressApplication;
+    ownershipGate;
+    acceptedRequests = new Set();
+    requestFailed = false;
+    setOwnershipGate(gate) { this.ownershipGate = gate; }
+    async drainRequests() {
+        while (this.acceptedRequests.size)
+            await Promise.all([...this.acceptedRequests]);
+        if (this.requestFailed)
+            throw new Error("An accepted HTTP request ended without confirmation");
+    }
+    async stop() {
+        await this.drainRequests();
+        if (this.server.listening)
+            await new Promise((resolve, reject) => {
+                this.server.close(error => error ? reject(error) : resolve());
+                this.server.closeIdleConnections?.();
+            });
+    }
     server;
     port;
     router;
@@ -42,6 +60,26 @@ export default class App {
         this.port = port;
         this.expressApplication = express();
         this.server = http.createServer(this.expressApplication);
+        this.expressApplication.use((_req, res, next) => {
+            if (!this.ownershipGate)
+                return next();
+            if (!this.ownershipGate()) {
+                res.setHeader("Retry-After", "1");
+                res.status(503).json({ error: "RUNTIME_PASSIVE", message: "Runtime ownership is being transferred. Retry the request." });
+                return;
+            }
+            let finish;
+            const accepted = new Promise(resolve => { finish = resolve; });
+            this.acceptedRequests.add(accepted);
+            res.once("finish", () => { this.acceptedRequests.delete(accepted); finish(); });
+            res.once("close", () => {
+                if (!res.writableFinished)
+                    this.requestFailed = true;
+                this.acceptedRequests.delete(accepted);
+                finish();
+            });
+            next();
+        });
         this.processName = processName;
         this.instanceName = instanceName;
         this.apiBasePrefix =

package/dist/uns-api-plugin.js

@@ -16,29 +16,50 @@ const unsApiPlugin = ({ define }) => {
             await this.waitForProcessConnection();
             const internals = this;
             const unsApiProxy = new UnsApiProxy(internals.processName, instanceName, options);
+            let owned = !this.usesStatefulHandover() || this.isActive();
+            const deferredMetadata = new Map();
+            const publishMetadata = (topic, payload) => {
+                if (!owned) {
+                    deferredMetadata.set(topic, payload);
+                    return;
+                }
+                return internals.processMqttProxy.publish(topic, payload);
+            };
+            if (this.usesStatefulHandover())
+                unsApiProxy.setOwnershipGate(() => owned);
+            this.registerLifecycleParticipant({
+                onRelease: () => { owned = false; },
+                drain: () => unsApiProxy.drainRequests(),
+                onActivate: async () => {
+                    owned = true;
+                    for (const [topic, payload] of deferredMetadata)
+                        await publishMetadata(topic, payload);
+                    deferredMetadata.clear();
+                },
+            });
             unsApiProxy.event.on("unsProxyProducedTopics", (event) => {
-                internals.processMqttProxy.publish(event.statusTopic, JSON.stringify(event.producedTopics));
+                publishMetadata(event.statusTopic, JSON.stringify(event.producedTopics));
             });
             unsApiProxy.event.on("unsProxyProducedApiEndpoints", (event) => {
-                internals.processMqttProxy.publish(event.statusTopic, JSON.stringify(event.producedApiEndpoints));
+                publishMetadata(event.statusTopic, JSON.stringify(event.producedApiEndpoints));
             });
             unsApiProxy.event.on("unsProxyProducedServiceEndpoints", (event) => {
-                internals.processMqttProxy.publish(event.statusTopic, JSON.stringify(event.producedServiceEndpoints));
+                publishMetadata(event.statusTopic, JSON.stringify(event.producedServiceEndpoints));
             });
             unsApiProxy.event.on("unsProxyProducedDataOfferEndpoints", (event) => {
-                internals.processMqttProxy.publish(event.statusTopic, JSON.stringify(event.producedDataOfferEndpoints));
+                publishMetadata(event.statusTopic, JSON.stringify(event.producedDataOfferEndpoints));
             });
             unsApiProxy.event.on("unsProxyProducedApiCatchAll", (event) => {
-                internals.processMqttProxy.publish(event.statusTopic, JSON.stringify(event.producedCatchall));
+                publishMetadata(event.statusTopic, JSON.stringify(event.producedCatchall));
             });
             unsApiProxy.event.on("unsProxyProducedDataCatalogOffers", (event) => {
-                internals.processMqttProxy.publish(event.statusTopic, JSON.stringify(event.producedDataCatalogOffers));
+                publishMetadata(event.statusTopic, JSON.stringify(event.producedDataCatalogOffers));
             });
             unsApiProxy.event.on("mqttProxyStatus", (event) => {
                 const time = UnsPacket.formatToISO8601(new Date());
                 const unsMessage = { data: { time, value: event.value, uom: event.uom } };
                 UnsPacket.unsPacketFromUnsMessage(unsMessage).then((packet) => {
-                    internals.processMqttProxy.publish(event.statusTopic, JSON.stringify(packet));
+                    publishMetadata(event.statusTopic, JSON.stringify(packet));
                 });
             });
             internals.unsApiProxies.push(unsApiProxy);

package/dist/uns-api-proxy.d.ts

@@ -21,6 +21,8 @@ export default class UnsApiProxy extends UnsProxy {
     private readonly statusIntervalMs;
     private readonly dataCatalogOffers;
     constructor(processName: string, instanceName: string, options: IApiProxyOptions);
+    setOwnershipGate(gate: () => boolean): void;
+    drainRequests(): Promise<void>;
     getProcessName(): string;
     private getPublishedApiHost;
     /**

package/dist/uns-api-proxy.js

@@ -92,6 +92,8 @@ export default class UnsApiProxy extends UnsProxy {
         setTimeout(() => this.emitStatusMetrics(), 0);
         this.statusInterval = setInterval(() => this.emitStatusMetrics(), this.statusIntervalMs);
     }
+    setOwnershipGate(gate) { this.app.setOwnershipGate(gate); }
+    async drainRequests() { await this.app.drainRequests(); }
     getProcessName() {
         return this.processName;
     }
@@ -728,6 +730,7 @@ export default class UnsApiProxy extends UnsProxy {
             clearInterval(this.statusInterval);
             this.statusInterval = null;
         }
+        await this.app.stop();
         await super.stop();
     }
     publishDataCatalogOffer(offer) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uns-kit/api",
-  "version": "3.0.36",
+  "version": "3.0.37",
   "description": "Express-powered API gateway plugin for UnsProxyProcess with JWT/JWKS support.",
   "type": "module",
   "license": "MIT",
@@ -37,7 +37,7 @@
     "multer": "^2.2.0",
     "hyparquet-writer": "^0.16.5",
     "uuid": "^14.0.1",
-    "@uns-kit/core": "3.0.36"
+    "@uns-kit/core": "3.0.37"
   },
   "devDependencies": {
     "@types/cookie-parser": "^1.4.10",