feat(api): dont load unnecessary data for unused widgets

closes #121
MauriceNino · Jun 19, 2022 · c166974 · c166974
1 parent 3b8f7c2
commit c166974
Show file tree

Hide file tree

Showing 4 changed files with 87 additions and 60 deletions.
diff --git a/apps/api/src/dynamic-info.ts b/apps/api/src/dynamic-info.ts
@@ -17,37 +17,43 @@ const exec = promisify(cexec);
 
 const createBufferedInterval = <R>(
   name: string,
+  enabled: boolean,
   bufferSize: number,
   intervalMs: number,
   factory: () => Promise<R>
 ): Observable<R> => {
   const buffer = new ReplaySubject<R>(bufferSize);
 
-  // Instantly load first value
-  factory()
-    .then(value => {
-      console.log(
-        `First measurement [${name}]:`,
-        inspect(value, {
-          showHidden: false,
-          depth: null,
-          colors: true,
-        })
-      );
+  if (enabled) {
+    // Instantly load first value
+    factory()
+      .then(value => {
+        console.log(
+          `First measurement [${name}]:`,
+          inspect(value, {
+            showHidden: false,
+            depth: null,
+            colors: true,
+          })
+        );
 
-      buffer.next(value);
-    })
-    .catch(err => buffer.error(err));
+        buffer.next(value);
+      })
+      .catch(err => buffer.error(err));
 
-  // Load values every intervalMs
-  interval(intervalMs).pipe(mergeMap(factory)).subscribe(buffer);
+    // Load values every intervalMs
+    interval(intervalMs).pipe(mergeMap(factory)).subscribe(buffer);
 
-  return buffer.asObservable();
+    return buffer.asObservable();
+  }
+
+  return new Observable();
 };
 
 export const getDynamicServerInfo = () => {
   const cpuObs = createBufferedInterval(
     'CPU',
+    CONFIG.widget_list.includes('cpu'),
     CONFIG.cpu_shown_datapoints,
     CONFIG.cpu_poll_interval,
     async (): Promise<CpuLoad> => {
@@ -73,6 +79,7 @@ export const getDynamicServerInfo = () => {
 
   const ramObs = createBufferedInterval(
     'RAM',
+    CONFIG.widget_list.includes('ram'),
     CONFIG.ram_shown_datapoints,
     CONFIG.ram_poll_interval,
     async (): Promise<RamLoad> => {
@@ -82,6 +89,7 @@ export const getDynamicServerInfo = () => {
 
   const storageObs = createBufferedInterval(
     'Storage',
+    CONFIG.widget_list.includes('storage'),
     1,
     CONFIG.storage_poll_interval,
     async (): Promise<StorageLoad> => {
@@ -99,6 +107,7 @@ export const getDynamicServerInfo = () => {
 
   const networkObs = createBufferedInterval(
     'Network',
+    CONFIG.widget_list.includes('network'),
     CONFIG.network_shown_datapoints,
     CONFIG.network_poll_interval,
     async (): Promise<NetworkLoad> => {
@@ -140,6 +149,7 @@ export const getDynamicServerInfo = () => {
 
   const gpuObs = createBufferedInterval(
     'GPU',
+    CONFIG.widget_list.includes('gpu'),
     CONFIG.gpu_shown_datapoints,
     CONFIG.gpu_poll_interval,
     async (): Promise<GpuLoad> => {
@@ -154,9 +164,11 @@ export const getDynamicServerInfo = () => {
     }
   );
 
-  const speedTestObs = interval(CONFIG.speed_test_interval * 60 * 1000).pipe(
-    mergeMap(async () => await runSpeedTest())
-  );
+  const speedTestObs = CONFIG.widget_list.includes('network')
+    ? interval(CONFIG.speed_test_interval * 60 * 1000).pipe(
+        mergeMap(async () => await runSpeedTest())
+      )
+    : new Observable();
 
   return {
     cpu: cpuObs,

diff --git a/apps/api/src/index.ts b/apps/api/src/index.ts
@@ -3,6 +3,7 @@ import * as cors from 'cors';
 import * as express from 'express';
 import * as http from 'http';
 import * as path from 'path';
+import { Subscription } from 'rxjs';
 import { Server } from 'socket.io';
 import { CONFIG } from './config';
 import { getDynamicServerInfo } from './dynamic-info';
@@ -47,49 +48,59 @@ server.listen(CONFIG.port, async () => {
 
   // Send current system status
   io.on('connection', socket => {
-    const cpuSub = obs.cpu.subscribe(cpu => {
-      socket.emit('cpu-load', cpu);
-    });
+    const subscriptions: Subscription[] = [];
 
-    const ramSub = obs.ram.subscribe(ram => {
-      socket.emit('ram-load', ram);
-    });
+    subscriptions.push(
+      obs.cpu.subscribe(cpu => {
+        socket.emit('cpu-load', cpu);
+      })
+    );
 
-    const storageSub = obs.storage.subscribe(async storage => {
-      socket.emit('storage-load', storage);
-    });
+    subscriptions.push(
+      obs.ram.subscribe(ram => {
+        socket.emit('ram-load', ram);
+      })
+    );
 
-    const networkSub = obs.network.subscribe(async network => {
-      socket.emit('network-load', network);
-    });
+    subscriptions.push(
+      obs.storage.subscribe(async storage => {
+        socket.emit('storage-load', storage);
+      })
+    );
 
-    const gpuSub = obs.gpu.subscribe(async gpu => {
-      socket.emit('gpu-load', gpu);
-    });
+    subscriptions.push(
+      obs.network.subscribe(async network => {
+        socket.emit('network-load', network);
+      })
+    );
+
+    subscriptions.push(
+      obs.gpu.subscribe(async gpu => {
+        socket.emit('gpu-load', gpu);
+      })
+    );
 
     socket.on('disconnect', () => {
-      cpuSub.unsubscribe();
-      ramSub.unsubscribe();
-      storageSub.unsubscribe();
-      networkSub.unsubscribe();
-      gpuSub.unsubscribe();
+      subscriptions.forEach(sub => sub.unsubscribe());
     });
   });
 
-  try {
-    console.log('Running speed-test (this may take a few minutes)...');
-    const usedRunner = await runSpeedTest();
-    console.log(
-      `Speed-test completed successfully [${usedRunner}]`,
-      getStaticServerInfo().network
-    );
-  } catch (e) {
-    console.warn(e);
-  }
+  if (CONFIG.widget_list.includes('network')) {
+    try {
+      console.log('Running speed-test (this may take a few minutes)...');
+      const usedRunner = await runSpeedTest();
+      console.log(
+        `Speed-test completed successfully [${usedRunner}]`,
+        getStaticServerInfo().network
+      );
+    } catch (e) {
+      console.warn(e);
+    }
 
-  obs.speedTest.subscribe({
-    error: e => console.warn(e),
-  });
+    obs.speedTest.subscribe({
+      error: e => console.warn(e),
+    });
+  }
 });
 
 server.on('error', console.error);

diff --git a/apps/api/src/static-info.ts b/apps/api/src/static-info.ts
@@ -264,14 +264,18 @@ export const runSpeedTest = async (): Promise<string> => {
   return usedRunner;
 };
 
+const promIf = (condition: boolean, func: () => Promise<any>): Promise<any> => {
+  return condition ? func() : Promise.resolve(null);
+};
+
 export const loadStaticServerInfo = async (): Promise<void> => {
   await Promise.all([
-    loadOsInfo(),
-    loadCpuInfo(),
-    loadRamInfo(),
-    loadStorageInfo(),
-    loadNetworkInfo(),
-    loadGpuInfo(),
+    promIf(CONFIG.widget_list.includes('os'), loadOsInfo),
+    promIf(CONFIG.widget_list.includes('cpu'), loadCpuInfo),
+    promIf(CONFIG.widget_list.includes('ram'), loadRamInfo),
+    promIf(CONFIG.widget_list.includes('storage'), loadStorageInfo),
+    promIf(CONFIG.widget_list.includes('network'), loadNetworkInfo),
+    promIf(CONFIG.widget_list.includes('gpu'), loadGpuInfo),
   ]);
 
   console.log(

diff --git a/apps/view/src/components/main-widget-container.tsx b/apps/view/src/components/main-widget-container.tsx
@@ -142,7 +142,7 @@ export const MainWidgetContainer: FC = () => {
     return () => {
       socket.close();
     };
-  }, [serverInfo.data]);
+  }, []);
 
   const errors = [
     {