@openshift-assisted/ui-lib 2.7.12-cim → 2.8.2-cim

package/lib/ocm/services/InfraEnvIdsCacheService.ts

@@ -0,0 +1,114 @@
+import { Cluster, CpuArchitecture, InfraEnv, getAllCpuArchitectures } from '../../common';
+
+const CACHE_KEY = 'infra-env-ids-cache-v2';
+
+type ClusterInfraEnvIds = Partial<Record<CpuArchitecture, InfraEnv['id']>>;
+type InfraEnvCache = Record<Cluster['id'], ClusterInfraEnvIds>;
+
+const update = (cache: InfraEnvCache): void => {
+  localStorage.setItem(CACHE_KEY, JSON.stringify(cache));
+};
+
+const read = (): InfraEnvCache => {
+  const EMPTY_CACHE = '{}';
+  const cache = localStorage.getItem(CACHE_KEY) || EMPTY_CACHE;
+
+  try {
+    return JSON.parse(cache) as InfraEnvCache;
+  } catch {
+    return {};
+  }
+};
+
+type InfraEnvStorage = Omit<Storage, 'getItem' | 'removeItem' | 'setItem'> & {
+  getInfraEnvId(clusterId: string, cpuArchitecture: CpuArchitecture): string | null;
+  removeInfraEnvId(clusterId: string, cpuArchitecture: CpuArchitecture): void;
+  removeInfraEnvs(clusterId: string): void;
+  updateInfraEnvs(clusterId: string, infraEnvs: InfraEnv[]): void;
+};
+
+const InfraEnvIdsCacheService: InfraEnvStorage = {
+  key(index: number): string | null {
+    const cache = read();
+    return Object.keys(cache)[index];
+  },
+
+  get length(): number {
+    const cache = read();
+    return Object.keys(cache).length;
+  },
+
+  clear(): void {
+    localStorage.removeItem(CACHE_KEY);
+  },
+
+  getInfraEnvId(clusterId: string, cpuArchitecture: CpuArchitecture): string | null {
+    if (!clusterId || !cpuArchitecture) {
+      return null;
+    }
+
+    const cache = read();
+    const clusterInfraEnvs = cache[clusterId];
+    if (!clusterInfraEnvs) {
+      return null;
+    }
+    if (cpuArchitecture !== CpuArchitecture.USE_DAY1_ARCHITECTURE) {
+      return clusterInfraEnvs[cpuArchitecture] || null;
+    }
+
+    const architectures = getAllCpuArchitectures().filter((arch) => {
+      return clusterInfraEnvs[arch];
+    });
+
+    if (architectures.length === 1) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      return clusterInfraEnvs[architectures[0]]!;
+    }
+    throw new Error(
+      `More than one infraEnv found for cluster ${clusterId} without specified architecture`,
+    );
+  },
+
+  removeInfraEnvId(clusterId: string, cpuArchitecture: CpuArchitecture): void {
+    if (!clusterId) {
+      return;
+    }
+
+    const cache = read();
+    if (cpuArchitecture === CpuArchitecture.USE_DAY1_ARCHITECTURE) {
+      delete cache[clusterId];
+    } else if (cache[clusterId]) {
+      delete cache[clusterId][cpuArchitecture];
+    }
+    update(cache);
+  },
+
+  removeInfraEnvs(clusterId: string): void {
+    if (!clusterId) {
+      return;
+    }
+
+    const cache = read();
+    delete cache[clusterId];
+    update(cache);
+  },
+
+  updateInfraEnvs(clusterId: string, infraEnvs: InfraEnv[]): void {
+    if (!clusterId) {
+      return;
+    }
+
+    const cache = read();
+    if (!cache[clusterId]) {
+      cache[clusterId] = {};
+    }
+    infraEnvs.forEach((infraEnv) => {
+      if (infraEnv.cpuArchitecture) {
+        cache[clusterId][infraEnv.cpuArchitecture as CpuArchitecture] = infraEnv.id;
+      }
+    });
+    update(cache);
+  },
+};
+
+export default InfraEnvIdsCacheService;

package/lib/ocm/services/InfraEnvsService.ts

@@ -0,0 +1,131 @@
+import { AxiosResponse } from 'axios';
+import {
+  Cluster,
+  CpuArchitecture,
+  HostStaticNetworkConfig,
+  InfraEnv,
+  InfraEnvCreateParams,
+} from '../../common';
+import { InfraEnvsAPI } from './apis';
+import InfraEnvCache from './InfraEnvIdsCacheService';
+import { getDummyInfraEnvField } from '../components/clusterConfiguration/staticIp/data/dummyData';
+
+const InfraEnvsService = {
+  async getInfraEnvId(clusterId: Cluster['id'], cpuArchitecture: CpuArchitecture): Promise<string> {
+    let infraEnvId = InfraEnvCache.getInfraEnvId(clusterId, cpuArchitecture);
+    if (infraEnvId === null) {
+      const { data: infraEnvs } = await InfraEnvsAPI.list(clusterId);
+      if (infraEnvs.length > 0) {
+        InfraEnvCache.updateInfraEnvs(clusterId, infraEnvs);
+        infraEnvId = InfraEnvCache.getInfraEnvId(clusterId, cpuArchitecture);
+      }
+      if (!infraEnvId) {
+        InfraEnvCache.removeInfraEnvId(clusterId, cpuArchitecture);
+        throw new Error(
+          `No InfraEnv could be found for clusterId: ${clusterId} and architecture ${
+            cpuArchitecture || ''
+          }`,
+        );
+      }
+    }
+    return infraEnvId;
+  },
+
+  async getInfraEnv(clusterId: Cluster['id'], cpuArchitecture: CpuArchitecture) {
+    const infraEnvId = await InfraEnvsService.getInfraEnvId(clusterId, cpuArchitecture);
+    if (infraEnvId) {
+      const { data } = await InfraEnvsAPI.get(infraEnvId);
+      return data;
+    } else {
+      throw new Error(
+        `No InfraEnv could be found for clusterId: ${clusterId} and architecture ${
+          cpuArchitecture || ''
+        }`,
+      );
+    }
+  },
+
+  async getAllInfraEnvIds(clusterId: Cluster['id']): Promise<string[]> {
+    const infraEnvs = await InfraEnvsService.getAllInfraEnvs(clusterId);
+    return infraEnvs.map((infraEnv) => infraEnv.id);
+  },
+
+  async getAllInfraEnvs(clusterId: Cluster['id']): Promise<InfraEnv[]> {
+    const { data: infraEnvs } = await InfraEnvsAPI.list(clusterId);
+    return infraEnvs;
+  },
+
+  async create(params: InfraEnvCreateParams) {
+    if (!params.clusterId) {
+      throw new Error('Cannot create InfraEnv, clusterId is missing');
+    }
+
+    const { data: infraEnv } = await InfraEnvsAPI.register(params);
+
+    if (!infraEnv.id) {
+      throw new Error('API returned no ID for the underlying InfraEnv');
+    }
+
+    InfraEnvCache.updateInfraEnvs(params.clusterId, [infraEnv]);
+  },
+
+  async removeAll(clusterId: Cluster['id']) {
+    const { data: infraEnvs } = await InfraEnvsAPI.list(clusterId);
+
+    const promises = infraEnvs.map((infraEnv) => {
+      return InfraEnvsAPI.deregister(infraEnv.id);
+    });
+
+    InfraEnvCache.removeInfraEnvs(clusterId);
+
+    return Promise.all(promises);
+  },
+
+  async updateAllInfraEnvsToDhcp(clusterId: Cluster['id']) {
+    const infraEnvIds = await InfraEnvsService.getAllInfraEnvIds(clusterId);
+    const infraEnvUpdates = infraEnvIds.map((id) =>
+      InfraEnvsAPI.update(id, {
+        staticNetworkConfig: [],
+      }),
+    );
+    return Promise.all(infraEnvUpdates);
+  },
+
+  async setDummyStaticConfigToInfraEnv(infraEnvId: InfraEnv['id']): Promise<InfraEnv> {
+    const { data } = await InfraEnvsAPI.update(infraEnvId, {
+      staticNetworkConfig: getDummyInfraEnvField(),
+    });
+    return data;
+  },
+
+  async syncStaticIpConfigs(
+    clusterId: Cluster['id'],
+    currentInfraEnvId: InfraEnv['id'],
+    staticNetworkConfig: HostStaticNetworkConfig[],
+  ): Promise<InfraEnv> {
+    // Updates staticIpConfigs on "currentInfraEnvId", and then it
+    const { data: updatedInfraEnv } = await InfraEnvsAPI.update(currentInfraEnvId, {
+      staticNetworkConfig,
+    });
+
+    const updateRequests: Promise<AxiosResponse<InfraEnv, unknown>>[] = [];
+    const infraEnvIds = await InfraEnvsService.getAllInfraEnvIds(clusterId);
+    infraEnvIds.forEach((infraEnvId) => {
+      // Copies the same configuration to the other infraEnvs of the same cluster
+      if (infraEnvId !== currentInfraEnvId) {
+        updateRequests.push(
+          InfraEnvsAPI.update(infraEnvId, {
+            staticNetworkConfig,
+          }),
+        );
+      }
+    });
+
+    // TODO (multi-arch) what should happen if one of the infraEnvs fails to get the same configuration
+    return Promise.all(updateRequests).then(() => {
+      return updatedInfraEnv;
+    });
+  },
+};
+
+export default InfraEnvsService;

package/lib/ocm/services/OperatorsService.tsx

@@ -0,0 +1,63 @@
+import {
+  Cluster,
+  OperatorsValues,
+  OperatorCreateParams,
+  OPERATOR_NAME_CNV,
+  OPERATOR_NAME_ODF,
+  OPERATOR_NAME_LSO,
+  OPERATOR_NAME_LVM,
+  OperatorName,
+} from '../../common';
+import { getOlmOperatorCreateParamsByName } from '../components/clusters/utils';
+import { getKeys } from '../../common/utils';
+
+const hasActiveOperators = (values: OperatorsValues) => {
+  return getKeys(values).some((operatorParam) => values[operatorParam]);
+};
+
+const OperatorsService = {
+  getOLMOperators(values: OperatorsValues, cluster: Cluster): OperatorCreateParams[] {
+    const enabledOlmOperatorsByName = getOlmOperatorCreateParamsByName(cluster);
+
+    // TODO: change OperatorName to ExposedOperatorName once the LSO option is exposed to the user
+    const setOperator = (name: OperatorName, enabled: boolean) => {
+      if (enabled) {
+        enabledOlmOperatorsByName[name] = { name };
+      } else {
+        delete enabledOlmOperatorsByName[name];
+      }
+    };
+
+    setOperator(OPERATOR_NAME_LVM, values.useOdfLogicalVolumeManager);
+    setOperator(OPERATOR_NAME_CNV, values.useContainerNativeVirtualization);
+    setOperator(OPERATOR_NAME_ODF, values.useOpenShiftDataFoundation);
+
+    // TODO: remove following once the LSO option is exposed to the user
+    if (!hasActiveOperators(values)) {
+      setOperator(OPERATOR_NAME_LSO, false);
+    }
+
+    return Object.values(enabledOlmOperatorsByName);
+  },
+
+  /**
+   * Depending on the Openshift version and certain selected operators, the
+   * Backend can activate some other operators.
+   * We need to synchronise them back to the form
+   */
+  syncOperators(
+    uiOperators: OperatorCreateParams[],
+    updatedOperators: Cluster['monitoredOperators'],
+  ): Partial<OperatorsValues> {
+    // LVM operator can be automatically selected depending on Openshift version + other operators
+    const prevInactive = uiOperators?.find((op) => op.name === OPERATOR_NAME_LVM) === undefined;
+    const nowActive = updatedOperators?.find((op) => op.name === OPERATOR_NAME_LVM) !== undefined;
+
+    const updates: Partial<OperatorsValues> = {};
+    if (prevInactive && nowActive) {
+      updates.useOdfLogicalVolumeManager = true;
+    }
+    return updates;
+  },
+};
+export default OperatorsService;

package/lib/ocm/services/apis/ClustersAPI.ts

@@ -0,0 +1,245 @@
+import { client } from '../../api/axiosClient';
+import {
+  Cluster,
+  ClusterCreateParams,
+  ClusterDefaultConfig,
+  V2ClusterUpdateParams,
+  Credentials,
+  Host,
+  ImportClusterParams,
+  PlatformType,
+  PreflightHardwareRequirements,
+  PresignedUrl,
+  ListManifests,
+  CreateManifestParams,
+  UpdateManifestParams,
+  Manifest,
+} from '../../../common/api/types';
+import { AxiosResponse } from 'axios';
+import { ClustersAPIGetPresignedOptions } from './types';
+let _getRequestAbortController = new AbortController();
+
+const ClustersAPI = {
+  abortLastGetRequest() {
+    _getRequestAbortController.abort();
+    /**
+     * The AbortController.signal can only be aborted once per instance.
+     * Therefore in order for other requests to be also abortable we need
+     * to create a new instance when this event occurs
+     */
+    _getRequestAbortController = new AbortController();
+  },
+
+  makeBaseURI(clusterId?: Cluster['id']) {
+    return `/v2/clusters/${clusterId ? clusterId : ''}`;
+  },
+
+  makeDownloadsBaseURI(clusterId: Cluster['id']) {
+    return `${ClustersAPI.makeBaseURI(clusterId)}/downloads`;
+  },
+
+  makeLogsBaseURI(clusterId: Cluster['id']) {
+    return `${ClustersAPI.makeBaseURI(clusterId)}/logs`;
+  },
+
+  makeDownloadsCredentialsBaseURI(clusterId: Cluster['id']) {
+    return `${ClustersAPI.makeDownloadsBaseURI(clusterId)}/credentials`;
+  },
+
+  makeDownloadsCredentialsPresignedBaseURI(clusterId: Cluster['id']) {
+    return `${ClustersAPI.makeDownloadsBaseURI(clusterId)}/credentials-presigned`;
+  },
+
+  makeDownloadsFilesPresignedBaseURI(clusterId: Cluster['id']) {
+    return `${ClustersAPI.makeDownloadsBaseURI(clusterId)}/files-presigned`;
+  },
+
+  makeSupportedPlatformsBaseURI(clusterId: Cluster['id']) {
+    return `${ClustersAPI.makeBaseURI(clusterId)}/supported-platforms`;
+  },
+
+  makeActionsBaseURI(clusterId: string) {
+    return `${ClustersAPI.makeBaseURI(clusterId)}/actions`;
+  },
+
+  downloadClusterCredentials(clusterId: Cluster['id'], fileName: string) {
+    return client.get<Blob>(
+      `${ClustersAPI.makeDownloadsCredentialsBaseURI(clusterId)}?file_name=${fileName}`,
+      {
+        responseType: 'blob',
+        headers: {
+          Accept: 'application/octet-stream',
+        },
+      },
+    );
+  },
+
+  getPresignedForClusterCredentials({
+    clusterId,
+    fileName,
+    hostId,
+    logsType,
+  }: ClustersAPIGetPresignedOptions) {
+    const queryParams = `${logsType ? `&logs_type=${logsType}` : ''}${
+      hostId ? `&host_id=${hostId}` : ''
+    }`;
+    return client.get<PresignedUrl>(
+      `${ClustersAPI.makeDownloadsCredentialsPresignedBaseURI(
+        clusterId,
+      )}?file_name=${fileName}${queryParams}`,
+    );
+  },
+
+  getPresignedForClusterFiles({
+    clusterId,
+    fileName,
+    hostId,
+    logsType,
+  }: ClustersAPIGetPresignedOptions) {
+    const queryParams = `${logsType ? `&logs_type=${logsType}` : ''}${
+      hostId ? `&host_id=${hostId}` : ''
+    }`;
+    return client.get<PresignedUrl>(
+      `${ClustersAPI.makeDownloadsFilesPresignedBaseURI(
+        clusterId,
+      )}?file_name=${fileName}${queryParams}`,
+    );
+  },
+
+  list() {
+    return client.get<Cluster[]>(`${ClustersAPI.makeBaseURI()}`, {
+      signal: _getRequestAbortController.signal,
+    });
+  },
+
+  get(clusterId: Cluster['id']) {
+    return client.get<Cluster>(`${ClustersAPI.makeBaseURI(clusterId)}`, {
+      signal: _getRequestAbortController.signal,
+    });
+  },
+
+  getSupportedPlatforms(clusterId: Cluster['id']) {
+    return client.get<PlatformType[]>(`${ClustersAPI.makeSupportedPlatformsBaseURI(clusterId)}`);
+  },
+
+  getPreflightRequirements(clusterId: Cluster['id']) {
+    return client.get<PreflightHardwareRequirements>(
+      `${ClustersAPI.makeBaseURI(clusterId)}/preflight-requirements`,
+    );
+  },
+
+  getDefaultConfig() {
+    return client.get<ClusterDefaultConfig>(`${ClustersAPI.makeBaseURI()}/default-config`);
+  },
+
+  deregister(clusterId: Cluster['id']) {
+    return client.delete<void>(`${ClustersAPI.makeBaseURI(clusterId)}`);
+  },
+
+  register(params: ClusterCreateParams) {
+    return client.post<Cluster, AxiosResponse<Cluster>, ClusterCreateParams>(
+      `${ClustersAPI.makeBaseURI()}`,
+      params,
+    );
+  },
+
+  update(clusterId: Cluster['id'], params: V2ClusterUpdateParams) {
+    return client.patch<Cluster, AxiosResponse<Cluster>, V2ClusterUpdateParams>(
+      `${ClustersAPI.makeBaseURI(clusterId)}`,
+      params,
+    );
+  },
+
+  install(clusterId: Cluster['id']) {
+    return client.post<Cluster, AxiosResponse<Cluster>, never>(
+      `${ClustersAPI.makeActionsBaseURI(clusterId)}/install`,
+    );
+  },
+
+  cancel(clusterId: Cluster['id']) {
+    return client.post<Cluster, AxiosResponse<Cluster>, never>(
+      `${ClustersAPI.makeActionsBaseURI(clusterId)}/cancel`,
+    );
+  },
+
+  reset(clusterId: Cluster['id']) {
+    return client.post<Cluster, AxiosResponse<Cluster>, never>(
+      `${ClustersAPI.makeActionsBaseURI(clusterId)}/reset`,
+    );
+  },
+
+  registerAddHosts(params: ImportClusterParams) {
+    return client.post<Cluster, AxiosResponse<Cluster>, ImportClusterParams>(
+      `${ClustersAPI.makeBaseURI()}import`,
+      params,
+    );
+  },
+
+  allowAddHosts(clusterId: Cluster['id']) {
+    return client.post<Cluster, AxiosResponse<Cluster>, never>(
+      `${ClustersAPI.makeActionsBaseURI(clusterId)}/allow-add-workers`,
+    );
+  },
+
+  downloadLogs(clusterId: Cluster['id'], hostId?: Host['id']) {
+    const queryParams = `logs_type=${!hostId ? 'all' : `host&host_id=${hostId}`}`;
+    return client.get<Blob>(`${ClustersAPI.makeLogsBaseURI(clusterId)}?${queryParams}`, {
+      responseType: 'blob',
+      headers: {
+        Accept: 'application/octet-stream',
+      },
+    });
+  },
+
+  getCredentials(clusterId: Cluster['id']) {
+    return client.get<Credentials>(`${ClustersAPI.makeBaseURI(clusterId)}/credentials`);
+  },
+
+  listByOpenshiftId(openshiftId: Cluster['openshiftClusterId']) {
+    return client.get<Cluster[]>(
+      `${ClustersAPI.makeBaseURI()}?openshift_cluster_id=${openshiftId || ''}`,
+    );
+  },
+
+  listBySubscriptionIds(subscriptionIds: Cluster['amsSubscriptionId'][]) {
+    return client.get<Cluster[]>(
+      `${ClustersAPI.makeBaseURI()}?ams_subscription_ids=${subscriptionIds.toString()}`,
+    );
+  },
+
+  getManifests(clusterId: Cluster['id']) {
+    return client.get<ListManifests>(`${ClustersAPI.makeBaseURI(clusterId)}/manifests`);
+  },
+  createCustomManifest(clusterId: Cluster['id'], params: CreateManifestParams) {
+    return client.post<Manifest, AxiosResponse<Manifest>, CreateManifestParams>(
+      `${ClustersAPI.makeBaseURI(clusterId)}/manifests`,
+      params,
+    );
+  },
+  removeCustomManifest(clusterId: Cluster['id'], folderName: string, fileName: string) {
+    return client.delete<void>(
+      `${ClustersAPI.makeBaseURI(clusterId)}/manifests?folder=${folderName}&file_name=${fileName}`,
+    );
+  },
+  getManifestContent(clusterId: Cluster['id'], folderName: string, fileName: string) {
+    return client.get<Blob>(
+      `${ClustersAPI.makeBaseURI(
+        clusterId,
+      )}/manifests/files?folder=${folderName}&file_name=${fileName}`,
+      {
+        responseType: 'blob',
+        headers: {
+          Accept: 'application/octet-stream',
+        },
+      },
+    );
+  },
+  updateCustomManifest(clusterId: Cluster['id'], params: UpdateManifestParams) {
+    return client.patch<Manifest, AxiosResponse<Manifest>, UpdateManifestParams>(
+      `${ClustersAPI.makeBaseURI(clusterId)}/manifests`,
+      params,
+    );
+  },
+};
+
+export default ClustersAPI;

package/lib/ocm/services/apis/ComponentVersionsAPI.ts

@@ -0,0 +1,14 @@
+import { client } from '../../api';
+import { ListVersions } from '../../../common';
+
+const ComponentVersionsAPI = {
+  makeBaseURI() {
+    return `/v2/component-versions`;
+  },
+
+  list() {
+    return client.get<ListVersions>(`${ComponentVersionsAPI.makeBaseURI()}`);
+  },
+};
+
+export default ComponentVersionsAPI;

package/lib/ocm/services/apis/EventsAPI.ts

@@ -0,0 +1,43 @@
+import { EventList, V2Events } from '../../../common';
+import { client } from '../../api';
+
+const EventsAPI = {
+  makeBaseURI() {
+    return '/v2/events';
+  },
+
+  createParams({
+    clusterId,
+    hostIds,
+    infraEnvId,
+    severities,
+    deletedHosts = true,
+    clusterLevel = true,
+    message,
+    limit = 10,
+    offset = 0,
+  }: V2Events) {
+    let params = '?';
+    params += 'order=descending&';
+
+    params += clusterId ? `cluster_id=${clusterId}&` : '';
+    params += hostIds?.length ? `host_ids=${hostIds.join(',')}&` : '';
+    params += infraEnvId ? `infra_env_id=${infraEnvId}&` : '';
+
+    params += severities?.length ? `severities=${severities?.join(',')}&` : '';
+    params += deletedHosts ? `deleted_hosts=${deletedHosts.toString()}&` : '';
+    params += clusterLevel ? `cluster_level=${clusterLevel.toString()}&` : '';
+    params += message ? `message=${encodeURIComponent(message)}&` : '';
+
+    params += `limit=${limit}&`;
+    params += `offset=${offset}`;
+
+    return params;
+  },
+
+  list(options: V2Events) {
+    return client.get<EventList>(`${EventsAPI.makeBaseURI()}${EventsAPI.createParams(options)}`);
+  },
+};
+
+export default EventsAPI;

package/lib/ocm/services/apis/FeatureSupportLevelsAPI.ts

@@ -0,0 +1,14 @@
+import { FeatureSupportLevels } from '../../../common/api/types';
+import { client } from '../../api/axiosClient';
+
+const FeatureSupportLevelsAPI = {
+  makeBaseURI() {
+    return `/v2/feature-support-levels`;
+  },
+
+  list() {
+    return client.get<FeatureSupportLevels>(FeatureSupportLevelsAPI.makeBaseURI());
+  },
+};
+
+export default FeatureSupportLevelsAPI;

package/lib/ocm/services/apis/HostsAPI.ts

@@ -0,0 +1,63 @@
+import { Host, HostUpdateParams, InfraEnv } from '../../../common';
+import { client } from '../../api';
+import { AxiosResponse } from 'axios';
+import InfraEnvsAPI from './InfraEnvsAPI';
+
+let _getRequestAbortController = new AbortController();
+
+const HostsAPI = {
+  abortLastGetRequest() {
+    _getRequestAbortController.abort();
+    /**
+     * The AbortController.signal can only be aborted once per instance.
+     * Therefore in order for other requests to be also abortable we need
+     * to create a new instance when this event occurs
+     */
+    _getRequestAbortController = new AbortController();
+  },
+
+  makeBaseURI(infraEnvId: InfraEnv['id'], hostId?: Host['id']) {
+    return `${InfraEnvsAPI.makeBaseURI(infraEnvId)}/hosts/${hostId ? hostId : ''}`;
+  },
+
+  makeActionsBaseURI(infraEnvId: InfraEnv['id'], hostId: Host['id']) {
+    return `${HostsAPI.makeBaseURI(infraEnvId, hostId)}/actions`;
+  },
+
+  list(infraEnvId: InfraEnv['id']) {
+    return client.get<Host[]>(`${HostsAPI.makeBaseURI(infraEnvId)}`, {
+      signal: _getRequestAbortController.signal,
+    });
+  },
+
+  get(infraEnvId: InfraEnv['id'], hostId: Host['id']) {
+    return client.get<Host>(`${HostsAPI.makeBaseURI(infraEnvId, hostId)}`, {
+      signal: _getRequestAbortController.signal,
+    });
+  },
+
+  update(infraEnvId: InfraEnv['id'], hostId: Host['id'], params: HostUpdateParams) {
+    return client.patch<Host, AxiosResponse<Host>, HostUpdateParams>(
+      `${HostsAPI.makeBaseURI(infraEnvId, hostId)}`,
+      params,
+    );
+  },
+
+  deregister(infraEnvId: InfraEnv['id'], hostId: Host['id']) {
+    return client.delete<void>(`${HostsAPI.makeBaseURI(infraEnvId, hostId)}`);
+  },
+
+  reset(infraEnvId: InfraEnv['id'], hostId: Host['id']) {
+    return client.post<Host, AxiosResponse<Host>, never>(
+      `${HostsAPI.makeActionsBaseURI(infraEnvId, hostId)}/reset`,
+    );
+  },
+
+  installHost(infraEnvId: InfraEnv['id'], hostId: Host['id']) {
+    return client.post<Host, AxiosResponse<Host>, never>(
+      `${HostsAPI.makeActionsBaseURI(infraEnvId, hostId)}/install`,
+    );
+  },
+};
+
+export default HostsAPI;