Merge pull request #153 from ISISComputingGroup/subscribe_in_one_go

subscribe in one go

Author: rerpha

app/components/Instrument.test.ts

@@ -7,9 +7,10 @@ import {
   RC_INRANGE,
   SP_RBV,
   storePrecision,
-  subscribeToBlockPVs,
+  getExtraPVsForBlock,
   toPrecision,
   yesToBoolean,
+  Instrument,
 } from "@/app/components/Instrument";
 import {
   ConfigOutput,
@@ -18,8 +19,6 @@ import {
   IfcGroup,
   IfcPV,
   IfcPVWSMessage,
-  IfcPVWSRequest,
-  PVWSRequestType,
 } from "@/app/types";
 
 test("findPVinDashboard finds a pv in the dashboard and returns it", () => {
@@ -109,20 +108,6 @@ test("findPVInGroups returns a block when it finds one", () => {
   findPVInGroups(groups, prefix, prefix + CSSB + blockName);
 });
 
-test("subscribeToBlockPVs subscribes to all run control PVs", () => {
-  const mockSendJsonMessage = jest.fn();
-  const aBlock = "INST:CS:SB:SomeBlock";
-  subscribeToBlockPVs(mockSendJsonMessage, aBlock);
-  expect(mockSendJsonMessage.mock.calls.length).toBe(1);
-  const expectedCall: IfcPVWSRequest = {
-    type: PVWSRequestType.subscribe,
-    pvs: [aBlock, aBlock + RC_ENABLE, aBlock + RC_INRANGE, aBlock + SP_RBV],
-  };
-  expect(JSON.stringify(mockSendJsonMessage.mock.calls[0][0])).toBe(
-    JSON.stringify(expectedCall),
-  );
-});
-
 test("toPrecision does nothing to string value ", () => {
   const expectedValue = "untouched";
   const aBlock: IfcBlock = {
@@ -165,8 +150,6 @@ test("yesToBoolean works with NO as value", () => {
 test("getGroupsWithBlocksFromConfigOutput gets blocks from blockserver groups", () => {
   const blockNameToTest = "aBlock";
   const groupNameToTest = "aGroup";
-  const prefix = "TESTING";
-  const mockSendJsonMessage = jest.fn();
 
   const configOutput: ConfigOutput = {
     groups: [{ blocks: [blockNameToTest], name: groupNameToTest }],
@@ -198,22 +181,14 @@ test("getGroupsWithBlocksFromConfigOutput gets blocks from blockserver groups",
     component_iocs: [],
     history: [],
   };
-  const groups = getGroupsWithBlocksFromConfigOutput(
-    configOutput,
-    mockSendJsonMessage,
-    prefix,
-  );
+  const groups = getGroupsWithBlocksFromConfigOutput(configOutput);
   expect(groups[0].name).toBe(groupNameToTest);
   expect(groups[0].blocks[0].human_readable_name).toBe(blockNameToTest);
 });
 
 test("subscribeToBlockPVs subscribes to blocks, their run control and their SP:RBV PVs", () => {
-  const mockSendJsonMessage = jest.fn();
   const blockAddress = "IN:INST:CS:SB:Block1";
-  subscribeToBlockPVs(mockSendJsonMessage, blockAddress);
-  expect(mockSendJsonMessage).toBeCalledTimes(1);
-  const call: Array<string> = mockSendJsonMessage.mock.calls[0][0].pvs;
-  expect(call).toEqual(
+  expect(getExtraPVsForBlock(blockAddress)).toEqual(
     expect.arrayContaining([
       blockAddress,
       blockAddress + RC_ENABLE,
@@ -234,3 +209,49 @@ test("storePrecision adds precision to a block if it is the first update", () =>
   storePrecision(message, blockWithoutPrecision);
   expect(blockWithoutPrecision.precision).toEqual(precision);
 });
+
+test("getAllBlockPVs returns flat list of blocks, their RC and SPRBV pvs", () => {
+  const block1Name = "blockName";
+  const block2Name = "block2Name";
+  const prefix = "IN:TEST:";
+
+  let inst = new Instrument(prefix);
+
+  inst.groups = [
+    {
+      name: "aGroup",
+      blocks: [
+        {
+          human_readable_name: block1Name,
+          pvaddress: "some:underlying:pv:name",
+        },
+      ],
+    },
+    {
+      name: "aDifferentGroup",
+      blocks: [
+        {
+          human_readable_name: block2Name,
+          pvaddress: "someother:underlying:pv:name",
+        },
+      ],
+    },
+  ];
+
+  const res = inst.getAllBlockPVs();
+
+  expect(res.length).toBe(2 * 4); // 2 blocks, which means 4 PVs to subscribe to
+
+  expect(res).toEqual(
+    expect.arrayContaining([
+      prefix + CSSB + block1Name,
+      prefix + CSSB + block1Name + RC_ENABLE,
+      prefix + CSSB + block1Name + RC_INRANGE,
+      prefix + CSSB + block1Name + SP_RBV,
+      prefix + CSSB + block2Name,
+      prefix + CSSB + block2Name + RC_ENABLE,
+      prefix + CSSB + block2Name + RC_INRANGE,
+      prefix + CSSB + block2Name + SP_RBV,
+    ]),
+  );
+});

app/components/Instrument.ts

@@ -6,8 +6,6 @@ import {
   IfcGroup,
   IfcPV,
   IfcPVWSMessage,
-  IfcPVWSRequest,
-  PVWSRequestType,
 } from "@/app/types";
 import {
   ExponentialOnThresholdFormat,
@@ -188,6 +186,16 @@ export class Instrument {
       },
     ];
   }
+
+  getAllBlockPVs(): Array<string> {
+    return this.groups
+      .map((g: IfcGroup) => g.blocks)
+      .flat(1) // flatten to a big array of blocks
+      .map((b: IfcBlock) =>
+        getExtraPVsForBlock(this.prefix + CSSB + b.human_readable_name),
+      )
+      .flat(1); //flatten block, rc, sp_rbv pvs for every block to a 1d array
+  }
 }
 
 export function findPVInDashboard(
@@ -211,34 +219,31 @@ export function toPrecision(
     : pvVal;
 }
 
-export function storePrecision(updatedPV: IfcPVWSMessage, block: IfcBlock) {
+export function storePrecision(
+  updatedPV: IfcPVWSMessage,
+  block: IfcBlock,
+): void {
   const prec = updatedPV.precision;
   if (prec != null && prec > 0 && !block.precision) {
     // this is likely the first update, and contains precision information which is not repeated on a normal value update - store this in the block for later truncation (see below)
     block.precision = prec;
   }
 }
 
-export function yesToBoolean(pvVal: string | number) {
+export function yesToBoolean(pvVal: string | number): boolean {
   return pvVal == "YES";
 }
 
-export function subscribeToBlockPVs(
-  sendJsonMessage: (a: IfcPVWSRequest) => void,
-  block_address: string,
-) {
+export function getExtraPVsForBlock(block_address: string): Array<string> {
   /**
-   * Subscribes to a block and its associated run control PVs
+   * Given a block name, give the run control and sp_rbv PVs.
    */
-  sendJsonMessage({
-    type: PVWSRequestType.subscribe,
-    pvs: [
-      block_address,
-      block_address + RC_ENABLE,
-      block_address + RC_INRANGE,
-      block_address + SP_RBV,
-    ],
-  });
+  return [
+    block_address,
+    block_address + RC_ENABLE,
+    block_address + RC_INRANGE,
+    block_address + SP_RBV,
+  ];
 }
 
 /**
@@ -247,17 +252,15 @@ export function subscribeToBlockPVs(
  */
 export function getGroupsWithBlocksFromConfigOutput(
   configOutput: ConfigOutput,
-  sendJsonMessage: (a: IfcPVWSRequest) => void,
-  prefix: string,
 ): Array<IfcGroup> {
-  const groups = configOutput.groups;
+  const configOutputGroups = configOutput.groups;
   let newGroups: Array<IfcGroup> = [];
-  for (const group of groups) {
-    const groupName = group.name;
+  for (const configOutputGroup of configOutputGroups) {
+    const groupName = configOutputGroup.name;
     let blocks: Array<IfcBlock> = [];
-    for (const block of group.blocks) {
+    for (const configOutputBlock of configOutputGroup.blocks) {
       const newBlock = configOutput.blocks.find(
-        (b: ConfigOutputBlock) => b.name === block,
+        (b: ConfigOutputBlock) => b.name === configOutputBlock,
       );
       if (newBlock) {
         blocks.push({
@@ -267,8 +270,6 @@ export function getGroupsWithBlocksFromConfigOutput(
           high_rc: newBlock.highlimit,
           visible: newBlock.visible,
         });
-        const fullyQualifiedBlockPVAddress = prefix + CSSB + newBlock.name;
-        subscribeToBlockPVs(sendJsonMessage, fullyQualifiedBlockPVAddress);
       }
     }
     newGroups.push({

app/components/InstrumentData.tsx

@@ -1,6 +1,11 @@
 "use client";
 import { useEffect, useState } from "react";
-import { IfcPVWSMessage, IfcPVWSRequest, PVWSRequestType } from "@/app/types";
+import {
+  IfcPV,
+  IfcPVWSMessage,
+  IfcPVWSRequest,
+  PVWSRequestType,
+} from "@/app/types";
 import {
   findPVInDashboard,
   findPVInGroups,
@@ -69,25 +74,18 @@ export function InstrumentData({ instrumentName }: { instrumentName: string }) {
       const updatedPVbytes: string | null | undefined = updatedPV.b64byt;
 
       if (updatedPVName == instListPV && updatedPVbytes != null) {
-        const instlist = instListFromBytes(updatedPVbytes);
-        const prefix = getPrefix(instlist, instName);
+        const prefix = getPrefix(instListFromBytes(updatedPVbytes), instName);
         const instrument = new Instrument(prefix);
         setCurrentInstrument(instrument);
 
+        // subscribe to dashboard and run info PVs
         sendJsonMessage({
           type: PVWSRequestType.subscribe,
-          pvs: [`${prefix}${CONFIG_DETAILS}`],
+          pvs: instrument.runInfoPVs
+            .concat(instrument.dashboard.flat(3))
+            .map((v: IfcPV) => v.pvaddress)
+            .concat([`${prefix}${CONFIG_DETAILS}`]),
         });
-
-        // subscribe to dashboard and run info PVs
-        for (const pv of instrument.runInfoPVs.concat(
-          instrument.dashboard.flat(3),
-        )) {
-          sendJsonMessage({
-            type: PVWSRequestType.subscribe,
-            pvs: [pv.pvaddress],
-          });
-        }
         return;
       }
 
@@ -105,12 +103,14 @@ export function InstrumentData({ instrumentName }: { instrumentName: string }) {
           return;
         }
         setLastUpdate(updatedPVbytes);
-        const res = dehex_and_decompress(atob(updatedPVbytes));
         currentInstrument.groups = getGroupsWithBlocksFromConfigOutput(
-          JSON.parse(res),
-          sendJsonMessage,
-          currentInstrument.prefix,
+          JSON.parse(dehex_and_decompress(atob(updatedPVbytes))),
         );
+
+        sendJsonMessage({
+          type: PVWSRequestType.subscribe,
+          pvs: currentInstrument.getAllBlockPVs(),
+        });
       } else {
         const pvVal = getPvValue(updatedPV);