Only fetch permissions on first load, not on every poll

The host table polls the API every 5 seconds while a job is running.
Previously every poll included include_permissions=true, causing a
backend permission check on each request.

Now permissions are only fetched on user-initiated calls (initial load,
page change, search/filter). Poll calls omit include_permissions and
instead merge the cached permissions back into each result so RowActions
continues to render correctly.

RowActions previously read permissions directly from the Redux store,
which was overwritten by each poll response (without permissions),
causing actions to disappear. It now receives permissions as a prop
from the table row where the merged data lives.

Author: adamruzicka

webpack/JobInvocationDetail/JobInvocationHostTable.js

@@ -72,6 +72,7 @@ const JobInvocationHostTable = ({
   const prevId = useRef(id);
   const pollTimeoutId = useRef(null);
   const currentPollParams = useRef({});
+  const cachedPermissions = useRef({});
   const jobFinishedRef = useRef(jobFinished);
   useEffect(() => {
     jobFinishedRef.current = jobFinished;
@@ -159,26 +160,42 @@ const JobInvocationHostTable = ({
     [initialFilter, urlSearchQuery]
   );
 
-  const updateHostsState = useCallback(data => {
-    const ids = data.data.results.map(i => i.id);
-    setApiResponse(data.data);
+  const updateHostsState = useCallback((data, isPoll) => {
+    const { results } = data.data;
+
+    if (!isPoll) {
+      cachedPermissions.current = Object.fromEntries(
+        results.map(result => [result.id, result.permissions])
+      );
+    }
+
+    const mergedResults = results.map(result => ({
+      ...result,
+      permissions: cachedPermissions.current[result.id],
+    }));
+
+    const ids = mergedResults.map(i => i.id);
+    setApiResponse({ ...data.data, results: mergedResults });
     setAllHostsIds(ids);
     setStatus(STATUS_UPPERCASE.RESOLVED);
   }, []);
 
   // Call hosts data with params
   const makeApiCall = useCallback(
-    requestParams => {
+    (requestParams, { isPoll = false } = {}) => {
       dispatch(
         APIActions.get({
           key: JOB_INVOCATION_HOSTS,
           url: `/api/job_invocations/${id}/hosts`,
-          params: { include_permissions: true, ...requestParams },
+          params: {
+            ...(!isPoll && { include_permissions: true }),
+            ...requestParams,
+          },
           handleSuccess: data => {
-            updateHostsState(data);
+            updateHostsState(data, isPoll);
             if (!jobFinishedRef.current) {
               pollTimeoutId.current = setTimeout(
-                () => makeApiCall(currentPollParams.current),
+                () => makeApiCall(currentPollParams.current, { isPoll: true }),
                 5000
               );
             } else {
@@ -487,7 +504,11 @@ const JobInvocationHostTable = ({
                     <Td key={k}>{columns[k].wrapper(result)}</Td>
                   ))}
                   <Td isActionCell>
-                    <RowActions hostID={result.id} jobID={id} />
+                    <RowActions
+                      hostID={result.id}
+                      jobID={id}
+                      permissions={result.permissions}
+                    />
                   </Td>
                 </Tr>
                 <Tr

webpack/JobInvocationDetail/TemplateInvocationComponents/TemplateActionButtons.js

@@ -81,11 +81,12 @@ const actions = ({
   },
 });
 
-export const RowActions = ({ hostID, jobID }) => {
+export const RowActions = ({ hostID, jobID, permissions: permissionsProp }) => {
   const dispatch = useDispatch();
   const response = useSelector(selectHostFromJobInvocationHosts(hostID));
-  if (!response?.permissions) return null;
-  const { task, permissions } = response;
+  const permissions = permissionsProp ?? response?.permissions;
+  if (!permissions) return null;
+  const { task } = response || {};
   const { id: taskID, cancellable: taskCancellable } = task || {};
   const getActions = actions({
     taskID,
@@ -216,4 +217,13 @@ TemplateActionButtons.defaultProps = {
 RowActions.propTypes = {
   hostID: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired,
   jobID: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired,
+  permissions: PropTypes.shape({
+    view_foreman_tasks: PropTypes.bool,
+    cancel_job_invocations: PropTypes.bool,
+    execute_jobs: PropTypes.bool,
+  }),
+};
+
+RowActions.defaultProps = {
+  permissions: null,
 };

webpack/JobInvocationDetail/__tests__/JobInvocationHostTablePolling.test.js

@@ -104,6 +104,9 @@ describe('JobInvocationHostTable polling', () => {
 
   beforeEach(() => {
     jest.useFakeTimers({ legacyFakeTimers: true });
+    jest
+      .requireMock('foremanReact/components/PF4/TableIndexPage/TableIndexPage')
+      .mockClear();
     apiGetSpy = jest
       .spyOn(api.APIActions, 'get')
       .mockImplementation(({ handleSuccess, ...action }) => {
@@ -219,6 +222,70 @@ describe('JobInvocationHostTable polling', () => {
     expect(apiGetSpy).toHaveBeenCalledTimes(1);
   });
 
+  describe('include_permissions behaviour', () => {
+    const hostWithPermissions = {
+      id: 1,
+      permissions: {
+        view_foreman_tasks: true,
+        cancel_job_invocations: true,
+        execute_jobs: true,
+      },
+    };
+
+    it('sends include_permissions on the first (non-poll) call', () => {
+      const store = makeStore();
+      renderAndTriggerFetch(store);
+
+      expect(apiGetSpy.mock.calls[0][0].params).toMatchObject({
+        include_permissions: true,
+      });
+    });
+
+    it('omits include_permissions on poll calls', () => {
+      const store = makeStore();
+      renderAndTriggerFetch(store);
+
+      act(() => jest.advanceTimersByTime(5000));
+
+      expect(apiGetSpy.mock.calls[1][0].params).not.toHaveProperty(
+        'include_permissions'
+      );
+    });
+
+    it('preserves permissions from the initial call in subsequent poll responses', () => {
+      apiGetSpy.mockImplementation(({ handleSuccess, params }) => {
+        handleSuccess &&
+          handleSuccess({
+            data: {
+              results: params.include_permissions ? [hostWithPermissions] : [{ id: 1 }],
+              total: 1,
+              subtotal: 1,
+            },
+          });
+        return { type: 'MOCK_GET' };
+      });
+
+      const store = makeStore();
+      renderAndTriggerFetch(store);
+
+      // Advance to the first poll — this call has no include_permissions,
+      // so the raw result has no permissions field.
+      act(() => jest.advanceTimersByTime(5000));
+
+      const MockTableIndexPage = jest.requireMock(
+        'foremanReact/components/PF4/TableIndexPage/TableIndexPage'
+      );
+      const replacementResponse =
+        MockTableIndexPage.mock.calls[
+          MockTableIndexPage.mock.calls.length - 1
+        ][0].replacementResponse;
+
+      expect(replacementResponse.response.results[0].permissions).toEqual(
+        hostWithPermissions.permissions
+      );
+    });
+  });
+
   it('uses the current id in the api url after id prop changes', () => {
     const store = makeStore();
     renderAndTriggerFetch(store, { id: '42' });