feat: loop check smb connection then prune

src/api.test.ts

@@ -5,7 +5,9 @@ describe('api', () => {
     const server = api({
       title: 'my awesome service',
       smbServerBaseUrl: 'http://localhost',
-      endpointIdleTimeout: '60'
+      endpointIdleTimeout: '60',
+      smbPoll: false,
+      smbPollInterval_s: '60'
     });
     const response = await server.inject({
       method: 'GET',

src/api.ts

@@ -41,6 +41,8 @@ export interface ApiOptions {
   title: string;
   smbServerBaseUrl: string;
   endpointIdleTimeout: string;
+  smbPoll: boolean;
+  smbPollInterval_s: string;
 }
 
 export default (opts: ApiOptions) => {
@@ -69,7 +71,9 @@ export default (opts: ApiOptions) => {
   // register other API routes here
   api.register(apiProductions, {
     smbServerBaseUrl: opts.smbServerBaseUrl,
-    endpointIdleTimeout: opts.endpointIdleTimeout
+    endpointIdleTimeout: opts.endpointIdleTimeout,
+    smbPoll: opts.smbPoll,
+    smbPollInterval_s: opts.smbPollInterval_s
   });
 
   return api;

src/api_productions.ts

@@ -1,7 +1,7 @@
 import { Type, Static } from '@sinclair/typebox';
 import { FastifyPluginCallback } from 'fastify';
 import { NewProduction, Production, Line } from './models';
-import { SmbProtocol, SmbEndpointDescription } from './smb';
+import { SmbProtocol, SmbEndpointDescription, DetailedConference } from './smb';
 import { ProductionManager } from './production_manager';
 import { Connection } from './connection';
 import { write, parse } from 'sdp-transform';
@@ -197,6 +197,8 @@ function getLine(productionLines: Line[], name: string): Line {
 export interface ApiProductionsOptions {
   smbServerBaseUrl: string;
   endpointIdleTimeout: string;
+  smbPoll: boolean;
+  smbPollInterval_s: string;
 }
 
 const apiProductions: FastifyPluginCallback<ApiProductionsOptions> = (
@@ -515,7 +517,66 @@ const apiProductions: FastifyPluginCallback<ApiProductionsOptions> = (
     }
   );
 
+  let parsedDelay_ms: number = parseInt(opts.smbPollInterval_s) * 1000;
+  if (parsedDelay_ms < 20000) {
+    parsedDelay_ms = 60000;
+  }
+
+  if (opts.smbPoll) {
+    startRepeatingPoll(smb, smbServerUrl, parsedDelay_ms);
+
+    setTimeout(() => {
+      stopRepeatingPoll();
+    }, 6000 * 60 * 10);
+  }
+
   next();
 };
 
+async function poll(smb: SmbProtocol, smbServerUrl: string) {
+  const productions: Production[] = productionManager.getProductions();
+
+  for (const production of productions) {
+    for (const line of production.lines) {
+      const endpoints: DetailedConference[] = await smb.getConference(
+        smbServerUrl,
+        line.id
+      );
+      const activeConnections: Record<string, SmbEndpointDescription> = {};
+      for (const endpoint of endpoints) {
+        const activeConnection: SmbEndpointDescription =
+          line.connections[endpoint['id']];
+        if (activeConnection) {
+          activeConnections[endpoint['id']] = activeConnection;
+        }
+      }
+      line.connections = activeConnections;
+      console.log(line.connections);
+    }
+  }
+}
+
+let intervalId: NodeJS.Timeout | null = null;
+
+function startRepeatingPoll(
+  smb: SmbProtocol,
+  smbServerUrl: string,
+  delay_ms: number
+) {
+  intervalId = setInterval(() => {
+    poll(smb, smbServerUrl);
+    console.log('Repeating poll running...');
+  }, delay_ms);
+}
+
+function stopRepeatingPoll() {
+  if (intervalId !== null) {
+    clearInterval(intervalId);
+    intervalId = null;
+    console.log('Repeating poll stopped.');
+  } else {
+    console.log('No repeating poll is currently running.');
+  }
+}
+
 export default apiProductions;

src/server.ts

@@ -9,10 +9,16 @@ if (!process.env.SMB_ADDRESS) {
 const ENDPOINT_IDLE_TIMEOUT_S: string =
   process.env.ENDPOINT_IDLE_TIMEOUT_S ?? '180';
 
+const SMB_POLL: boolean = process.env.SMB_POLL === 'true';
+
+const SMB_POLL_INTERVAL_S: string = process.env.SMB_POLL_INTERVAL_S ?? '60';
+
 const server = api({
   title: 'intercom-manager',
   smbServerBaseUrl: SMB_ADDRESS,
-  endpointIdleTimeout: ENDPOINT_IDLE_TIMEOUT_S
+  endpointIdleTimeout: ENDPOINT_IDLE_TIMEOUT_S,
+  smbPoll: SMB_POLL,
+  smbPollInterval_s: SMB_POLL_INTERVAL_S
 });
 
 const PORT = process.env.PORT ? Number(process.env.PORT) : 8000;

src/smb.ts

@@ -91,6 +91,19 @@ interface BaseAllocationRequest {
   idleTimeout?: number;
 }
 
+export interface DetailedConference {
+  dtlsState: string;
+  iceState: string;
+  id: string;
+  isActiveTalker: boolean;
+  isDominantSpeaker: boolean;
+  ActiveTalker?: {
+    noiseLevel: number;
+    ptt: boolean;
+    score: number;
+  };
+}
+
 export class SmbProtocol {
   async allocateConference(smbUrl: string): Promise<string> {
     const allocateResponse = await fetch(smbUrl, {
@@ -202,4 +215,21 @@ export class SmbProtocol {
     const responseBody: string[] = await response.json();
     return responseBody;
   }
+
+  async getConference(
+    smbUrl: string,
+    conferenceId: string
+  ): Promise<DetailedConference[]> {
+    const url = smbUrl + conferenceId;
+    const response = await fetch(url, {
+      method: 'GET'
+    });
+
+    if (!response.ok) {
+      return [];
+    }
+
+    const responseBody: DetailedConference[] = await response.json();
+    return responseBody;
+  }
 }