export default async function fetchRunInfo()

in client/src/components/runs/logs/misc/fetch-run-info.js [47:180]
122 lines of code
23 McCabe index (conditional complexity)

export default async function fetchRunInfo (
  runIdentifier,
  dataCallback,
  options
) {
  const {
    maxNestedRunsToDisplay = 10,
    preferences,
    dockerRegistries
  } = options || {};
  let stopped = false;
  const runInfo = new PipelineRunInfo(runIdentifier);
  const runTasks = new RunTasks(runIdentifier);
  const totalNestedRuns = new RunCount({
    parentId: Number(runIdentifier),
    statuses: ALL_STATUSES,
    onlyMasterJobs: false
  });
  await Promise.all([
    runInfo.fetch(),
    runTasks.fetch(),
    totalNestedRuns.fetch(),
    dockerRegistries ? dockerRegistries.fetchIfNeededOrWait() : false
  ].filter(Boolean));
  let hasNestedRuns = totalNestedRuns.runsCount > 0;
  if (runInfo.error || !runInfo.loaded) {
    throw new Error(runInfo.error || 'Error fetching run info');
  }
  const showActiveWorkersOnly = await getShowActiveWorkersOnly(runInfo.value, preferences);
  const {
    status = 'RUNNING',
    dockerImage,
    pipelineId,
    version
  } = runInfo.value;
  const commitAllowed = await checkCommitAllowedForTool(dockerImage, dockerRegistries);
  if (typeof dataCallback === 'function') {
    dataCallback({
      run: runInfo.value,
      runTasks: runTasks.value || [],
      showActiveWorkersOnly,
      language: undefined,
      commitAllowed,
      hasNestedRuns,
      totalNestedRuns: 0,
      nestedRunsPending: true
    });
  }
  const nestedRuns = new PipelineRunSingleFilter(
    {
      page: 1,
      pageSize: maxNestedRunsToDisplay,
      eagerGrouping: false,
      parentId: runIdentifier,
      statuses: showActiveWorkersOnly
        ? ['RUNNING']
        : []
    },
    false
  );
  await nestedRuns.filter();
  let pipelineLanguage;
  if (pipelineId && version) {
    pipelineLanguage = new PipelineLanguage(pipelineId, version);
  }
  let currentStatus = status;
  const isAutoUpdate = () => /^(running|pausing|resuming)$/i.test(currentStatus);
  const call = async () => {
    if (isAutoUpdate() && !stopped) {
      await Promise.all([
        runInfo.fetch(),
        nestedRuns.filter(),
        runTasks.fetch(),
        pipelineLanguage ? pipelineLanguage.fetchIfNeededOrWait() : false
      ].filter(Boolean));
      if (runInfo.networkError) {
        throw new Error(runInfo.networkError);
      }
    }
  };
  const commit = () => {
    const run = runInfo.value || {};
    const {
      status: nextStatus
    } = run;
    currentStatus = nextStatus;
    const error = runInfo.error;
    hasNestedRuns = hasNestedRuns || (nestedRuns.total || 0) > 0;
    const data = {
      run,
      nestedRuns: nestedRuns.value || [],
      hasNestedRuns,
      totalNestedRuns: nestedRuns.total || 0,
      nestedRunsPending: false,
      error,
      showActiveWorkersOnly,
      runTasks: runTasks.value || [],
      language: pipelineLanguage && pipelineLanguage.loaded ? pipelineLanguage.value : undefined,
      commitAllowed
    };
    if (typeof dataCallback === 'function' && !stopped) {
      dataCallback(data);
    }
    return data;
  };
  const result = commit();
  let stop = () => {
    stopped = true;
  };
  const reFetch = async () => new Promise((resolve) => {
    runInfo.fetch()
      .catch(() => {})
      .then(() => commit())
      .then(() => resolve());
  });
  if (isAutoUpdate()) {
    const {
      stop: stopAutoUpdate
    } = continuousFetch({
      call,
      afterInvoke: commit,
      fetchImmediate: false
    });
    stop = () => {
      stopped = true;
      stopAutoUpdate();
    };
  }
  return {
    stop,
    fetch: reFetch,
    data: result
  };
}