export const getAllNodeVersions = async (callCluster: CallCluster) => {
  // Get the version information for all nodes in the cluster.
  const { nodes } = (await callCluster('nodes.info', {
    filterPath: 'nodes.*.version',
  })) as { nodes: { [nodeId: string]: { version: string } } };

  const versionStrings = Object.values(nodes).map(({ version }) => version);

  return uniq(versionStrings)
    .sort()
    .map(version => new SemVer(version));
};

  const switchAlias = async (reindexOp: ReindexSavedObject) => {
    const { indexName, newIndexName } = reindexOp.attributes;

    const existingAliases = (await callCluster('indices.getAlias', {
      index: indexName,
    }))[indexName].aliases;

    const extraAlises = Object.keys(existingAliases).map(aliasName => ({
      add: { index: newIndexName, alias: aliasName, ...existingAliases[aliasName] },
    }));

    const aliasResponse = await callCluster('indices.updateAliases', {
      body: {
        actions: [
          { add: { index: newIndexName, alias: indexName } },
          { remove_index: { index: indexName } },
          ...extraAlises,
        ],
      },
    });

    if (!aliasResponse.acknowledged) {
      throw Boom.badImplementation(`Index aliases could not be created.`);
    }

    return actions.updateReindexOp(reindexOp, {
      lastCompletedStep: ReindexStep.aliasCreated,
    });
  };

  const cleanupChanges = async (reindexOp: ReindexSavedObject) => {
    // Cancel reindex task if it was started but not completed
    if (reindexOp.attributes.lastCompletedStep === ReindexStep.reindexStarted) {
      await callCluster('tasks.cancel', {
        taskId: reindexOp.attributes.reindexTaskId,
      }).catch(e => undefined); // Ignore any exceptions trying to cancel (it may have already completed).
    }

    // Set index back to writable if we ever got past this point.
    if (reindexOp.attributes.lastCompletedStep >= ReindexStep.readonly) {
      await callCluster('indices.putSettings', {
        index: reindexOp.attributes.indexName,
        body: { 'index.blocks.write': false },
      });
    }

    if (
      reindexOp.attributes.lastCompletedStep >= ReindexStep.newIndexCreated &&
      reindexOp.attributes.lastCompletedStep < ReindexStep.aliasCreated
    ) {
      await callCluster('indices.delete', { index: reindexOp.attributes.newIndexName });
    }

    // Resume consumers if we ever got past this point.
    if (reindexOp.attributes.lastCompletedStep >= ReindexStep.indexGroupServicesStopped) {
      await resumeIndexGroupServices(reindexOp);
    }

    return reindexOp;
  };

    await actions.runWhileIndexGroupLocked(IndexGroup.watcher, async watcherDoc => {
      const { acknowledged } = await callCluster('transport.request', {
        path: '/_watcher/_stop',
        method: 'POST',
      });

      if (!acknowledged) {
        throw new Error('Could not stop Watcher');
      }

      return watcherDoc;
    });

    await actions.runWhileIndexGroupLocked(IndexGroup.ml, async mlDoc => {
      await validateNodesMinimumVersion(6, 7);

      const res = await callCluster('transport.request', {
        path: '/_ml/set_upgrade_mode?enabled=true',
        method: 'POST',
      });

      if (!res.acknowledged) {
        throw new Error(`Could not stop ML jobs`);
      }

      return mlDoc;
    });