foreman_remote_execution 16.7.0 → 17.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87f61f660cc9bb15e87453747aca6cef5d600d4fd3994d090c5af8a4e48f1b8a
-  data.tar.gz: 16e86afd877b2c2dec48daba1ff05c98822208a9c777d5351a9bf04edbd21322
+  metadata.gz: d0c5f9e975897ee24ccf2c91fafe81e998742ec7453ca0e7cf3aea4846962b23
+  data.tar.gz: 20f9ca73d78bd41ce758b3ac39e1e880be6630230eb64d735850a88ae7b9cbec
 SHA512:
-  metadata.gz: 16a08a5afdbab46351b5fe9eb4fcf55c82ad0a56160585dbedbec48a32e2d47c9f595a8562505d5c97f69141d5e6174c0fcbb6e3fd0df481dd692b6c2b811b91
-  data.tar.gz: f1e886b6f85fc08820986b812d2d959b65c42e49ab411a42df47da1ec5ad077842f472f58e78f635fd71712fdf15a7bf2541d6921fc1d3788ebec9be1bcad995
+  metadata.gz: 57609a9b217ab4e7e5e60536a6a4de788b26d46d09f68330ca385fbd4df59d65cabc33581026ba15795aacbfc96b1fe6a97b735e006dfcf0a51188032ea525b9
+  data.tar.gz: 23d742ef78d0f9dc5cc205d541c74a8c3a3472618c4e67a6cb1c5c94c552a2ea6aa601ce38b498f9fae2403227f0efdf44055fefe8cc90df1de86e3c7b6fc96f

data/app/views/api/v2/job_invocations/main.json.rabl

@@ -34,6 +34,7 @@ end
 
 child :task do
   attributes :id, :state, :started_at
+  node(:cancellable) { |task| task.try(:cancellable?) }
 end
 
 if @template_invocations

data/app/views/job_templates/_alerts.html.erb

@@ -0,0 +1,4 @@
+<% if @template.locked? -%>
+  <%= locked_warning(::Template.find(params[:id])) %>
+<% end -%>
+

data/lib/foreman_remote_execution/plugin.rb

@@ -1,5 +1,5 @@
 Foreman::Plugin.register :foreman_remote_execution do
-  requires_foreman '>= 3.17'
+  requires_foreman '>= 5.0'
   register_global_js_file 'global'
   register_gettext
 

data/lib/foreman_remote_execution/version.rb

@@ -1,3 +1,3 @@
 module ForemanRemoteExecution
-  VERSION = '16.7.0'.freeze
+  VERSION = '17.0.0'.freeze
 end

data/webpack/JobInvocationDetail/JobInvocationActions.js

@@ -1,52 +1,67 @@
 import { translate as __, sprintf } from 'foremanReact/common/I18n';
-import { foremanUrl } from 'foremanReact/common/helpers';
 import { addToast } from 'foremanReact/components/ToastsList';
-import { APIActions, get } from 'foremanReact/redux/API';
-import {
-  stopInterval,
-  withInterval,
-} from 'foremanReact/redux/middlewares/IntervalMiddleware';
+import { APIActions } from 'foremanReact/redux/API';
 import {
   CANCEL_JOB,
   CANCEL_RECURRING_LOGIC,
   CHANGE_ENABLED_RECURRING_LOGIC,
-  GET_TASK,
   JOB_INVOCATION_KEY,
-  UPDATE_JOB,
+  STATUS,
 } from './JobInvocationConstants';
 
-export const getJobInvocation = url => dispatch => {
-  const fetchData = withInterval(
-    get({
-      key: JOB_INVOCATION_KEY,
-      params: { include_permissions: true, include_hosts: false },
-      url,
-      handleError: () => {
-        dispatch(stopInterval(JOB_INVOCATION_KEY));
-      },
-      errorToast: ({ response }) =>
-        // eslint-disable-next-line camelcase
-        response?.data?.error?.full_messages?.[0] ||
-        // eslint-disable-next-line camelcase
-        response?.data?.error?.full_messages ||
-        response?.data?.error?.message ||
-        'Error',
-    }),
-    1000
-  );
+const POLL_INTERVAL = 5000;
+
+export const isJobFinished = statusLabel =>
+  statusLabel === STATUS.FAILED ||
+  statusLabel === STATUS.SUCCEEDED ||
+  statusLabel === STATUS.CANCELLED;
+
+const extractErrorMessage = response =>
+  // eslint-disable-next-line camelcase
+  response?.data?.error?.full_messages?.[0] ||
+  response?.data?.error?.message ||
+  __('Unknown error.');
+
+const createPollState = cancel => ({ timeoutId: null, cancel });
 
-  dispatch(fetchData);
+export const getJobInvocation = (url, pollTimeoutRef) => dispatch => {
+  let cancelled = false;
+
+  const poll = () => {
+    if (cancelled) return;
+    dispatch(
+      APIActions.get({
+        key: JOB_INVOCATION_KEY,
+        params: { include_permissions: true, include_hosts: false },
+        url,
+        handleSuccess: ({ data }) => {
+          if (cancelled) return;
+          // eslint-disable-next-line camelcase
+          pollTimeoutRef.current.timeoutId = isJobFinished(data?.status_label)
+            ? null
+            : setTimeout(poll, POLL_INTERVAL);
+        },
+        handleError: () => {
+          if (cancelled) return;
+          pollTimeoutRef.current.timeoutId = null;
+        },
+        errorToast: ({ response }) => extractErrorMessage(response),
+      })
+    );
+  };
+
+  stopJobInvocationPolling(pollTimeoutRef);
+  pollTimeoutRef.current = createPollState(() => {
+    cancelled = true;
+  });
+
+  poll();
 };
 
-export const updateJob = jobId => dispatch => {
-  const url = foremanUrl(`/api/job_invocations/${jobId}`);
-  dispatch(
-    APIActions.get({
-      url,
-      key: UPDATE_JOB,
-      params: { include_hosts: false },
-    })
-  );
+export const stopJobInvocationPolling = pollTimeoutRef => {
+  clearTimeout(pollTimeoutRef.current.timeoutId);
+  pollTimeoutRef.current.cancel();
+  pollTimeoutRef.current = createPollState(() => {});
 };
 
 export const cancelJob = (jobId, force) => dispatch => {
@@ -54,10 +69,6 @@ export const cancelJob = (jobId, force) => dispatch => {
     force
       ? sprintf(__('Trying to abort the job %s.'), jobId)
       : sprintf(__('Trying to cancel the job %s.'), jobId);
-  const errorToast = response =>
-    force
-      ? sprintf(__(`Could not abort the job %s: ${response}`), jobId)
-      : sprintf(__(`Could not cancel the job %s: ${response}`), jobId);
   const url = force
     ? `/job_invocations/${jobId}/cancel?force=true`
     : `/job_invocations/${jobId}/cancel`;
@@ -67,12 +78,17 @@ export const cancelJob = (jobId, force) => dispatch => {
       url,
       key: CANCEL_JOB,
       errorToast: ({ response }) =>
-        errorToast(
-          // eslint-disable-next-line camelcase
-          response?.data?.error?.full_messages ||
-            response?.data?.error?.message ||
-            'Unknown error.'
-        ),
+        force
+          ? sprintf(
+              __('Could not abort the job %s: %s'),
+              jobId,
+              extractErrorMessage(response)
+            )
+          : sprintf(
+              __('Could not cancel the job %s: %s'),
+              jobId,
+              extractErrorMessage(response)
+            ),
       handleSuccess: () => {
         dispatch(
           addToast({
@@ -81,40 +97,16 @@ export const cancelJob = (jobId, force) => dispatch => {
             message: infoToast(),
           })
         );
-        dispatch(updateJob(jobId));
       },
     })
   );
 };
 
-export const getTask = taskId => dispatch => {
-  dispatch(
-    get({
-      key: GET_TASK,
-      url: `/foreman_tasks/api/tasks/${taskId}`,
-    })
-  );
-};
-
-export const enableRecurringLogic = (
-  recurrenceId,
-  enabled,
-  jobId
-) => dispatch => {
+export const enableRecurringLogic = (recurrenceId, enabled) => dispatch => {
   const successToast = () =>
     enabled
       ? sprintf(__('Recurring logic %s disabled successfully.'), recurrenceId)
       : sprintf(__('Recurring logic %s enabled successfully.'), recurrenceId);
-  const errorToast = response =>
-    enabled
-      ? sprintf(
-          __(`Could not disable recurring logic %s: ${response}`),
-          recurrenceId
-        )
-      : sprintf(
-          __(`Could not enable recurring logic %s: ${response}`),
-          recurrenceId
-        );
   const url = `/foreman_tasks/api/recurring_logics/${recurrenceId}`;
   dispatch(
     APIActions.put({
@@ -123,25 +115,24 @@ export const enableRecurringLogic = (
       params: { recurring_logic: { enabled: !enabled } },
       successToast,
       errorToast: ({ response }) =>
-        errorToast(
-          // eslint-disable-next-line camelcase
-          response?.data?.error?.full_messages ||
-            response?.data?.error?.message ||
-            'Unknown error.'
-        ),
-      handleSuccess: () => dispatch(updateJob(jobId)),
+        enabled
+          ? sprintf(
+              __('Could not disable recurring logic %s: %s'),
+              recurrenceId,
+              extractErrorMessage(response)
+            )
+          : sprintf(
+              __('Could not enable recurring logic %s: %s'),
+              recurrenceId,
+              extractErrorMessage(response)
+            ),
     })
   );
 };
 
-export const cancelRecurringLogic = (recurrenceId, jobId) => dispatch => {
+export const cancelRecurringLogic = recurrenceId => dispatch => {
   const successToast = () =>
     sprintf(__('Recurring logic %s cancelled successfully.'), recurrenceId);
-  const errorToast = response =>
-    sprintf(
-      __(`Could not cancel recurring logic %s: ${response}`),
-      recurrenceId
-    );
   const url = `/foreman_tasks/recurring_logics/${recurrenceId}/cancel`;
   dispatch(
     APIActions.post({
@@ -149,13 +140,11 @@ export const cancelRecurringLogic = (recurrenceId, jobId) => dispatch => {
       key: CANCEL_RECURRING_LOGIC,
       successToast,
       errorToast: ({ response }) =>
-        errorToast(
-          // eslint-disable-next-line camelcase
-          response?.data?.error?.full_messages ||
-            response?.data?.error?.message ||
-            'Unknown error.'
+        sprintf(
+          __('Could not cancel recurring logic %s: %s'),
+          recurrenceId,
+          extractErrorMessage(response)
         ),
-      handleSuccess: () => dispatch(updateJob(jobId)),
     })
   );
 };

data/webpack/JobInvocationDetail/JobInvocationConstants.js

@@ -6,9 +6,7 @@ import { useForemanHostDetailsPageUrl } from 'foremanReact/Root/Context/ForemanC
 import JobStatusIcon from '../react_app/components/RecentJobsCard/JobStatusIcon';
 
 export const JOB_INVOCATION_KEY = 'JOB_INVOCATION_KEY';
-export const UPDATE_JOB = 'UPDATE_JOB';
 export const CANCEL_JOB = 'CANCEL_JOB';
-export const GET_TASK = 'GET_TASK';
 export const GET_TEMPLATE_INVOCATIONS = 'GET_TEMPLATE_INVOCATIONS';
 export const CHANGE_ENABLED_RECURRING_LOGIC = 'CHANGE_ENABLED_RECURRING_LOGIC';
 export const CANCEL_RECURRING_LOGIC = 'CANCEL_RECURRING_LOGIC';
@@ -20,6 +18,8 @@ export const DIRECT_OPEN_HOST_LIMIT = 3;
 export const ALL_JOB_HOSTS = 'ALL_JOB_HOSTS';
 export const AWAITING_STATUS_FILTER = '(job_invocation.result = N/A)';
 
+export const AUTO_REFRESH_INTERVAL_MS = 5000;
+
 export const showTemplateInvocationUrl = (hostID, jobID) =>
   `/show_template_invocation_by_host/${hostID}/job_invocation/${jobID}`;
 export const LIST_TEMPLATE_INVOCATIONS = 'LIST_TEMPLATE_INVOCATIONS';
@@ -38,6 +38,7 @@ export const STATUS = {
   SUCCEEDED: 'succeeded',
   FAILED: 'failed',
   CANCELLED: 'cancelled',
+  RUNNING: 'running',
 };
 
 export const STATUS_UPPERCASE = {

data/webpack/JobInvocationDetail/JobInvocationHostTable.js

@@ -41,8 +41,8 @@ import Columns, {
   JOB_INVOCATION_HOSTS,
   LIST_TEMPLATE_INVOCATIONS,
   STATUS_UPPERCASE,
-  ALL_JOB_HOSTS,
   AWAITING_STATUS_FILTER,
+  AUTO_REFRESH_INTERVAL_MS,
 } from './JobInvocationConstants';
 import { TemplateInvocation } from './TemplateInvocation';
 import { RowActions } from './TemplateInvocationComponents/TemplateActionButtons';
@@ -51,8 +51,8 @@ import { PopupAlert } from './OpenAllInvocationsModal';
 const JobInvocationHostTable = ({
   id,
   initialFilter,
+  jobFinished,
   onFilterUpdate,
-  statusLabel,
   targeting,
 }) => {
   const columns = Columns();
@@ -69,7 +69,17 @@ const JobInvocationHostTable = ({
 
   // Expansive items
   const [expandedHost, setExpandedHost] = useState(new Set());
-  const prevStatusLabel = useRef(statusLabel);
+  const prevJobFinished = useRef(jobFinished);
+  const prevFilter = useRef('');
+  const prevId = useRef(id);
+  const pollTimeoutId = useRef(null);
+  const currentPollParams = useRef({});
+  const mountedRef = useRef(true);
+  const requestIdRef = useRef(0);
+  const jobFinishedRef = useRef(jobFinished);
+  useEffect(() => {
+    jobFinishedRef.current = jobFinished;
+  }, [jobFinished]);
 
   const [hostInvocationStates, setHostInvocationStates] = useState({});
 
@@ -153,33 +163,50 @@ const JobInvocationHostTable = ({
     [initialFilter, urlSearchQuery]
   );
 
-  const handleResponse = useCallback((data, key) => {
-    if (key === JOB_INVOCATION_HOSTS) {
-      const ids = data.data.results.map(i => i.id);
-
-      setApiResponse(data.data);
-      setAllHostsIds(ids);
-    }
-
+  const updateHostsState = useCallback(data => {
+    const ids = data.data.results.map(i => i.id);
+    setApiResponse(data.data);
+    setAllHostsIds(ids);
     setStatus(STATUS_UPPERCASE.RESOLVED);
   }, []);
 
   // Call hosts data with params
   const makeApiCall = useCallback(
-    (requestParams, callParams = {}) => {
+    requestParams => {
+      requestIdRef.current += 1;
+      const thisRequest = requestIdRef.current;
       dispatch(
         APIActions.get({
-          key: callParams.key ?? ALL_JOB_HOSTS,
-          url: callParams.url ?? `/api/job_invocations/${id}/hosts`,
+          key: JOB_INVOCATION_HOSTS,
+          url: `/api/job_invocations/${id}/hosts`,
           params: requestParams,
-          handleSuccess: data => handleResponse(data, callParams.key),
-          handleError: () => setStatus(STATUS_UPPERCASE.ERROR),
+          handleSuccess: data => {
+            if (thisRequest !== requestIdRef.current) return;
+            if (!mountedRef.current) return;
+            updateHostsState(data);
+            if (!jobFinishedRef.current) {
+              pollTimeoutId.current = setTimeout(
+                () => makeApiCall(currentPollParams.current),
+                AUTO_REFRESH_INTERVAL_MS
+              );
+            } else {
+              pollTimeoutId.current = null;
+            }
+          },
+          handleError: () => {
+            if (thisRequest !== requestIdRef.current) return;
+            if (!mountedRef.current) return;
+            pollTimeoutId.current = null;
+            setStatus(STATUS_UPPERCASE.ERROR);
+          },
           errorToast: ({ response }) =>
-            response?.data?.error?.full_messages?.[0] || response,
+            response?.data?.error?.full_messages?.[0] ||
+            response?.data?.error?.message ||
+            __('Failed to load host invocation data'),
         })
       );
     },
-    [dispatch, id, handleResponse]
+    [dispatch, id, updateHostsState]
   );
 
   const filterApiCall = useCallback(
@@ -202,7 +229,11 @@ const JobInvocationHostTable = ({
         finalParams.search = filterSearch;
       }
 
-      makeApiCall(finalParams, { key: JOB_INVOCATION_HOSTS });
+      currentPollParams.current = finalParams;
+      clearTimeout(pollTimeoutId.current);
+      pollTimeoutId.current = null;
+
+      makeApiCall(finalParams);
 
       const urlSearchParams = new URLSearchParams(window.location.search);
 
@@ -222,26 +253,17 @@ const JobInvocationHostTable = ({
     ]
   );
 
-  // Filter change
-  const handleFilterChange = useCallback(
-    newFilter => {
-      onFilterUpdate(newFilter);
-    },
-    [onFilterUpdate]
-  );
-
   // Effects
   // run after mount
   const initializedRef = useRef(false);
   useEffect(() => {
     if (!initializedRef.current) {
-      // Job Invo template load
-      makeApiCall(
-        {},
-        {
-          url: `/job_invocations/${id}/hosts`,
+      dispatch(
+        APIActions.get({
           key: LIST_TEMPLATE_INVOCATIONS,
-        }
+          url: `/job_invocations/${id}/hosts`,
+          params: {},
+        })
       );
 
       if (initialFilter === '') {
@@ -249,16 +271,28 @@ const JobInvocationHostTable = ({
       }
       initializedRef.current = true;
     }
-  }, [makeApiCall, id, initialFilter, onFilterUpdate]);
+  }, [dispatch, id, initialFilter, onFilterUpdate]);
 
   useEffect(() => {
-    if (initialFilter !== '') filterApiCall();
-
-    if (statusLabel !== prevStatusLabel.current) {
-      prevStatusLabel.current = statusLabel;
+    const filterChanged = initialFilter !== prevFilter.current;
+    const statusChanged = jobFinished !== prevJobFinished.current;
+    const idChanged = id !== prevId.current;
+
+    if ((filterChanged || statusChanged || idChanged) && initialFilter !== '') {
+      prevFilter.current = initialFilter;
+      prevJobFinished.current = jobFinished;
+      prevId.current = id;
       filterApiCall();
     }
-  }, [initialFilter, statusLabel, id, filterApiCall]);
+  }, [initialFilter, jobFinished, id, filterApiCall]);
+
+  useEffect(
+    () => () => {
+      mountedRef.current = false;
+      clearTimeout(pollTimeoutId.current);
+    },
+    []
+  );
 
   const {
     updateSearchQuery: updateSearchQueryBulk,
@@ -403,7 +437,7 @@ const JobInvocationHostTable = ({
           <DropdownFilter
             key="dropdown-filter"
             dropdownFilter={initialFilter}
-            setDropdownFilter={handleFilterChange}
+            setDropdownFilter={onFilterUpdate}
           />,
           <CheckboxesActions
             bulkParams={selectedCount > 0 ? fetchBulkParams() : null}
@@ -541,13 +575,13 @@ JobInvocationHostTable.propTypes = {
   id: PropTypes.string.isRequired,
   targeting: PropTypes.object.isRequired,
   initialFilter: PropTypes.string.isRequired,
-  statusLabel: PropTypes.string,
+  jobFinished: PropTypes.bool,
   onFilterUpdate: PropTypes.func,
 };
 
 JobInvocationHostTable.defaultProps = {
   onFilterUpdate: () => {},
-  statusLabel: undefined,
+  jobFinished: false,
 };
 
 export default JobInvocationHostTable;

data/webpack/JobInvocationDetail/JobInvocationSelectors.js

@@ -5,7 +5,6 @@ import {
 } from 'foremanReact/redux/API/APISelectors';
 import {
   JOB_INVOCATION_KEY,
-  GET_TASK,
   GET_TEMPLATE_INVOCATION,
   LIST_TEMPLATE_INVOCATIONS,
 } from './JobInvocationConstants';
@@ -13,10 +12,8 @@ import {
 export const selectItems = state =>
   selectAPIResponse(state, JOB_INVOCATION_KEY);
 
-export const selectTask = state => selectAPIResponse(state, GET_TASK);
-
 export const selectTaskCancelable = state =>
-  selectTask(state).available_actions?.cancellable || false;
+  selectItems(state).task?.cancellable || false;
 
 export const selectTemplateInvocation = hostID => state =>
   selectAPIResponse(state, `${GET_TEMPLATE_INVOCATION}_${hostID}`);

data/webpack/JobInvocationDetail/JobInvocationToolbarButtons.js

@@ -58,6 +58,12 @@ const JobInvocationToolbarButtons = ({ jobId, data }) => {
     );
   }, [jobId, reportTemplateJobId, templateInputId]);
 
+  const isCreateReportDisabled =
+    !canGenerateReportTemplates ||
+    task?.state === STATUS.RUNNING ||
+    task?.state === STATUS.PENDING ||
+    reportHref === undefined;
+
   const onActionFocus = useCallback(() => {
     const element = document.getElementById(
       `toggle-split-button-action-primary-${jobId}`
@@ -135,9 +141,7 @@ const JobInvocationToolbarButtons = ({ jobId, data }) => {
             <DropdownItem
               ouiaId="change-enabled-recurring-dropdown-item"
               onClick={() =>
-                dispatch(
-                  enableRecurringLogic(recurrence?.id, recurringEnabled, jobId)
-                )
+                dispatch(enableRecurringLogic(recurrence?.id, recurringEnabled))
               }
               key="change-enabled-recurring"
               component="button"
@@ -153,9 +157,7 @@ const JobInvocationToolbarButtons = ({ jobId, data }) => {
             </DropdownItem>,
             <DropdownItem
               ouiaId="cancel-recurring-dropdown-item"
-              onClick={() =>
-                dispatch(cancelRecurringLogic(recurrence?.id, jobId))
-              }
+              onClick={() => dispatch(cancelRecurringLogic(recurrence?.id))}
               key="cancel-recurring"
               component="button"
               isDisabled={
@@ -168,7 +170,7 @@ const JobInvocationToolbarButtons = ({ jobId, data }) => {
             </DropdownItem>,
           ]
         : [],
-    [recurrence, recurringEnabled, canEditRecurringLogic, dispatch, jobId]
+    [recurrence, recurringEnabled, canEditRecurringLogic, dispatch]
   );
 
   const dropdownItems = useMemo(
@@ -280,11 +282,7 @@ const JobInvocationToolbarButtons = ({ jobId, data }) => {
             className="button-create-report"
             href={reportHref}
             variant="secondary"
-            isDisabled={
-              !canGenerateReportTemplates ||
-              task?.state === STATUS.PENDING ||
-              reportHref === undefined
-            }
+            isDisabled={isCreateReportDisabled}
           >
             {__(`Create report`)}
           </Button>

data/webpack/JobInvocationDetail/TemplateInvocation.js

@@ -11,6 +11,7 @@ import {
   showTemplateInvocationUrl,
   templateInvocationPageUrl,
   GET_TEMPLATE_INVOCATION,
+  AUTO_REFRESH_INTERVAL_MS,
 } from './JobInvocationConstants';
 import {
   selectTemplateInvocationStatus,
@@ -67,7 +68,7 @@ export const TemplateInvocation = ({
   showCommand,
   setShowCommand,
 }) => {
-  const intervalRef = useRef(null);
+  const timeoutRef = useRef(null);
   const templateURL = showTemplateInvocationUrl(hostID, jobID);
   const hostDetailsPageUrl = useForemanHostDetailsPageUrl();
 
@@ -81,43 +82,48 @@ export const TemplateInvocation = ({
   }, [response]);
 
   useEffect(() => {
-    const dispatchFetch = () => {
+    let cancelled = false;
+
+    const schedulePoll = () => {
+      if (cancelled) return;
       dispatch(
         APIActions.get({
           url: templateURL,
           key: `${GET_TEMPLATE_INVOCATION}_${hostID}`,
+          handleSuccess: ({ data }) => {
+            if (cancelled) return;
+            const isFinished = data?.finished ?? true;
+            // eslint-disable-next-line camelcase
+            const autoRefresh = data?.auto_refresh || false;
+            if (!isFinished && autoRefresh) {
+              timeoutRef.current = setTimeout(
+                schedulePoll,
+                AUTO_REFRESH_INTERVAL_MS
+              );
+            } else {
+              timeoutRef.current = null;
+            }
+          },
+          handleError: () => {
+            if (cancelled) return;
+            timeoutRef.current = null;
+          },
         })
       );
     };
 
-    if (intervalRef.current) {
-      clearInterval(intervalRef.current);
-      intervalRef.current = null;
-    }
+    clearTimeout(timeoutRef.current);
+    timeoutRef.current = null;
 
     if (isExpanded) {
-      if (isEmpty(responseRef.current)) {
-        dispatchFetch();
-      }
-
-      intervalRef.current = setInterval(() => {
-        const latestResponse = responseRef.current;
-        const finished = latestResponse?.finished ?? true;
-        // eslint-disable-next-line camelcase
-        const autoRefresh = latestResponse?.auto_refresh || false;
-
-        if (!finished && autoRefresh) {
-          dispatchFetch();
-        } else if (intervalRef.current) {
-          clearInterval(intervalRef.current);
-        }
-      }, 5000);
+      if (responseRef.current?.finished) return undefined;
+      schedulePoll();
     }
 
     return () => {
-      if (intervalRef.current) {
-        clearInterval(intervalRef.current);
-      }
+      cancelled = true;
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
     };
   }, [isExpanded, dispatch, templateURL, hostID]);