@alauda-fe/common 1.0.0-next.0

package/esm2022/api/k8s-api.service.mjs

@@ -0,0 +1,394 @@
+/**
+ * @packageDocumentation
+ * @module api
+ */
+import { HttpClient, HttpEventType, } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { get, isEqual, set } from 'lodash-es';
+import { NEVER, Observable, combineLatest, from, of, throwError, filter, map, retryWhen, startWith, switchMap, concatMap, delay, distinctUntilChanged, } from 'rxjs';
+import { CRYPTO_HEADER_KEY, } from '../core';
+import { API_GATEWAY, DOWNGRADE_WATCH_ENABLED, NOTIFY_ON_ERROR_HEADERS, NOT_NOTIFY_ON_ERROR_HEADERS, TRUE, } from '../core/constants/constants';
+import { TOKEN_GLOBAL_NAMESPACE } from '../core/constants/tokens';
+import { METADATA, NAME, NAMESPACE } from '../core/services';
+import { parseJSONStream } from '../core/utils';
+import { createPollObservable } from '../core/utils/observable';
+import { normalizeParams } from '../k8s-resource-list/utils';
+import { getApiPrefixParts, getMetadataHeaders, isResourceEvent, reduceWatchEvents, } from './helpers';
+import { K8sApiResourceService } from './k8s-api-resource.service';
+import { PageVisibilityService } from './page-visibility.service';
+import { PatchOperation, WatchEvent, } from './types';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./k8s-api-resource.service";
+import * as i3 from "./page-visibility.service";
+// 名称前缀 Erebus 参考 http://confluence.alauda.cn/pages/viewpage.action?pageId=44663484 指 /kubernetes/ 开头的 api 组件
+export const TIMEOUT_SECONDS = 59;
+export const SEARCH_URL_PREFIX = '/acp/v1/resources/search';
+const RETRY_DELAY = 5000;
+const RETRY_COUNT = 3;
+export class K8sApiService {
+    constructor(http, k8sApiResource, pageVisibility, globalNamespace) {
+        this.http = http;
+        this.k8sApiResource = k8sApiResource;
+        this.pageVisibility = pageVisibility;
+        this.globalNamespace = globalNamespace;
+        // @internal
+        this._getHeaders = ({ notifyOnError, onlyMetadata, customAccept, crypto }, isList) => {
+            const headers = {};
+            if (typeof notifyOnError === 'boolean') {
+                Object.assign(headers, notifyOnError ? NOTIFY_ON_ERROR_HEADERS : NOT_NOTIFY_ON_ERROR_HEADERS);
+            }
+            if (crypto) {
+                Object.assign(headers, {
+                    [CRYPTO_HEADER_KEY]: crypto,
+                });
+            }
+            /**
+             * @see https://github.com/kubernetes/design-proposals-archive/blob/main/api-machinery/alternate-api-representations.md
+             */
+            if (onlyMetadata) {
+                Object.assign(headers, getMetadataHeaders(isList, customAccept));
+            }
+            return headers;
+        };
+    }
+    /**
+     * 获取 Global 集群单个资源对象
+     */
+    getGlobalResource(params) {
+        return this._getResource(params);
+    }
+    /**
+     * 监听 Global 集群单个资源对象
+     */
+    watchGlobalResource(params) {
+        return DOWNGRADE_WATCH_ENABLED && params.downgradePolling
+            ? createPollObservable(this.getGlobalResource(params), this._getDowngradePolling(params)).pipe(distinctUntilChanged((a, b) => isEqual(a, b)))
+            : this._watchResource(params);
+    }
+    /**
+     * 监听 Global 集群资源列表变化
+     */
+    watchGlobalResourceChange(seedVersion, params) {
+        return this._keepWatchResourceChange(seedVersion, params);
+    }
+    /**
+     * 获取 Global 集群资源对象列表，包含分页信息
+     */
+    getGlobalResourceList(params) {
+        return this._getResourceList(params);
+    }
+    /**
+     * 创建 Global 集群资源
+     */
+    postGlobalResource(params) {
+        return this._postResource(params);
+    }
+    /**
+     * 完整覆盖更新 Global 集群单个资源对象
+     */
+    putGlobalResource(params) {
+        return this._putResource(params);
+    }
+    /**
+     * 增量更新 Global 集群单个资源对象的部分属性
+     */
+    patchGlobalResource(params) {
+        return this._patchResource(params);
+    }
+    /**
+     * 删除 Global 集群单个资源
+     */
+    deleteGlobalResource(params) {
+        return this._deleteResource(params);
+    }
+    /**
+     * 获取业务集群单个资源对象
+     */
+    getResource(params) {
+        return this._getResource(params);
+    }
+    /**
+     * 监听业务集群单个资源对象
+     */
+    watchResource(params) {
+        return DOWNGRADE_WATCH_ENABLED && params.downgradePolling
+            ? createPollObservable(this._getResource(params), this._getDowngradePolling(params)).pipe(distinctUntilChanged((a, b) => isEqual(a, b)))
+            : this._watchResource(params);
+    }
+    /**
+     * 监听资源列表变化
+     */
+    watchResourceChange(seedVersion, params) {
+        return this._keepWatchResourceChange(seedVersion, params);
+    }
+    /**
+     * 获取业务集群资源对象列表，包含分页信息
+     */
+    getResourceList(params) {
+        return this._getResourceList(params);
+    }
+    /**
+     * 创建业务集群资源
+     */
+    postResource(params) {
+        return this._postResource(params);
+    }
+    /**
+     * 完整覆盖更新业务集群单个资源对象
+     */
+    putResource(params) {
+        return this._putResource(params);
+    }
+    /**
+     * 增量更新业务集群单个资源对象的部分属性
+     */
+    patchResource(params) {
+        return this._patchResource(params);
+    }
+    /**
+     * 删除业务集群单个资源
+     */
+    deleteResource(params) {
+        if ('name' in params && !params.name) {
+            return throwError(() => new Error('delete resource need resource name'));
+        }
+        return this._deleteResource(params);
+    }
+    /**
+     * 批量删除业务集群的资源
+     */
+    batchDeleteResource(params) {
+        return this._batchDeleteResource(params);
+    }
+    // @internal
+    _getResourceDefinition(params) {
+        const definition = this.k8sApiResource.getDefinition('definition' in params && params.definition
+            ? params.definition
+            : 'type' in params && params.type);
+        if ('resource' in params && params.resource) {
+            return {
+                type: definition.type,
+                ...getApiPrefixParts(params.resource.apiVersion),
+            };
+        }
+        return definition;
+    }
+    // @internal
+    _getApiPath(params, ignoreName = false) {
+        return this.k8sApiResource.getApiPath({
+            ...this._getResourceDefinition(params),
+            cluster: 'cluster' in params && params.cluster,
+            namespace: this._getNamespace(params),
+            name: ignoreName ? null : this._getName(params),
+        });
+    }
+    // @internal
+    _getNamespace(params) {
+        return 'namespace' in params && params.namespace
+            ? params.namespace
+            : 'namespaced' in params && params.namespaced
+                ? this.globalNamespace
+                : 'resource' in params && get(params.resource, [METADATA, NAMESPACE]);
+    }
+    // @internal
+    _getName(params) {
+        return 'name' in params
+            ? params.name
+            : 'resource' in params && get(params.resource, [METADATA, NAME]);
+    }
+    /**
+     * k8s list api 返回的结果里，items 缺失 kind 和 apiVersion 字段
+     * 规则如 Service 类型对应 kind: ServiceList，去掉最后四个字符可得到资源的 kind
+     * @internal
+     */
+    _getNormalizedList(list) {
+        const { apiVersion, items } = list;
+        if (!items || items.length === 0) {
+            return {
+                ...list,
+                items: [],
+            };
+        }
+        const kind = list.kind.slice(0, -4);
+        return {
+            ...list,
+            items: items.map(item => ({
+                // key 顺序会影响转 yaml 后的顺序
+                kind,
+                apiVersion,
+                ...item,
+            })),
+        };
+    }
+    // @internal
+    _getResource(params) {
+        return this.http.get(this._getApiPath(params), {
+            headers: this._getHeaders(params),
+        });
+    }
+    // @internal
+    _watchResource(params) {
+        const detailParams = {
+            ...params,
+            queryParams: { fieldSelector: 'metadata.name=' + this._getName(params) },
+        };
+        const defaultRetry = {
+            count: RETRY_COUNT,
+            delay: RETRY_DELAY,
+        };
+        const { count, delay: delayTime } = params.retry === true
+            ? {
+                ...defaultRetry,
+                count: Infinity,
+            }
+            : {
+                ...defaultRetry,
+                ...params.retry,
+            };
+        let soFar = 0;
+        return this._getResourceList(detailParams).pipe(switchMap(list => this._keepWatchResourceChange(list.metadata.resourceVersion, detailParams).pipe(filter(isResourceEvent), map(res => (res.type === WatchEvent.Deleted ? null : res.object)), startWith(list.items[0] ?? null))), retryWhen(err$ => err$.pipe(switchMap(err => {
+            if (err === WatchEvent.Error || (count && soFar++ < count)) {
+                return of(err).pipe(delay(count ? delayTime : 0));
+            }
+            return throwError(() => err);
+        }))));
+    }
+    // @internal
+    _keepWatchResourceChange(seedVersion, params) {
+        let resourceVersion = seedVersion;
+        let sub;
+        const watch$ = new Observable(observer => {
+            const unsubscribe = () => {
+                if (sub && !sub.closed) {
+                    sub.unsubscribe();
+                }
+            };
+            const watch = () => {
+                unsubscribe();
+                sub = this._watchResourceChange({
+                    ...params,
+                    queryParams: normalizeParams({
+                        ...params.queryParams,
+                        watch: TRUE,
+                        allowWatchBookmarks: TRUE,
+                        timeoutSeconds: String(TIMEOUT_SECONDS),
+                        resourceVersion,
+                    }),
+                }).subscribe({
+                    next(res) {
+                        if (res.type === WatchEvent.Error) {
+                            observer.error(res.type);
+                            return;
+                        }
+                        resourceVersion = res.object.metadata.resourceVersion;
+                        observer.next(res);
+                    },
+                    error(err) {
+                        observer.error(err);
+                    },
+                    complete: watch,
+                });
+            };
+            watch();
+            return unsubscribe;
+        });
+        return params.keepalive
+            ? watch$
+            : combineLatest([
+                this.pageVisibility.getPageVisibility(),
+                params.active$ || of(true),
+            ]).pipe(switchMap(([visible, active]) => visible && active ? watch$ : NEVER));
+    }
+    // @internal
+    _watchResourceChange(params) {
+        return this.http
+            .get(this._getApiPath(params, true), {
+            responseType: 'text',
+            observe: 'events',
+            reportProgress: true,
+            headers: this._getHeaders(params),
+            params: params.queryParams,
+        })
+            .pipe(filter(ev => ev.type === HttpEventType.DownloadProgress), filter(({ partialText }) => !!partialText?.trim()), concatMap(({ partialText }) => from(reduceWatchEvents(parseJSONStream(partialText)))));
+    }
+    // @internal
+    _getResourceList(params) {
+        // 包含 keyword 前缀需要加上前缀 'acp/v1/resources/search'
+        // 参考 http://confluence.alauda.cn/pages/viewpage.action?pageId=48731058
+        let url = this._getApiPath(params, true);
+        const queryParams = { ...params.queryParams };
+        if (queryParams.keyword) {
+            url = url.replace(API_GATEWAY, `${API_GATEWAY}${SEARCH_URL_PREFIX}`);
+            if (!queryParams.field) {
+                queryParams.field = 'metadata.name';
+            }
+        }
+        return this.http
+            .get(url, {
+            params: queryParams,
+            headers: this._getHeaders(params, true),
+        })
+            .pipe(map(this._getNormalizedList));
+    }
+    // @internal
+    _postResource(params) {
+        if (('namespace' in params && params.namespace) ||
+            ('namespaced' in params && params.namespaced)) {
+            const resourceNamespace = get(params.resource, [METADATA, NAMESPACE]);
+            if (!resourceNamespace) {
+                set(params.resource, [METADATA, NAMESPACE], params.namespace || this.globalNamespace);
+            }
+        }
+        return this.http.post(this._getApiPath(params, true), params.resource, {
+            headers: this._getHeaders(params),
+        });
+    }
+    // @internal
+    _putResource(params) {
+        return this.http.put(this._getApiPath(params), params.resource, {
+            headers: this._getHeaders(params),
+        });
+    }
+    // @internal
+    _patchResource(params) {
+        return this.http.patch(this._getApiPath(params), params.part, {
+            headers: {
+                ...this._getHeaders(params),
+                'Content-Type': params.operation || PatchOperation.Merge,
+            },
+        });
+    }
+    // @internal
+    _deleteResource(params) {
+        return this.http.request('delete', this._getApiPath(params), {
+            headers: this._getHeaders(params),
+            body: params.body,
+        });
+    }
+    // @internal
+    _batchDeleteResource(params) {
+        return this.http.request('delete', this._getApiPath(params), {
+            headers: this._getHeaders(params),
+            body: params.body,
+            params: params.queryParams,
+        });
+    }
+    _getDowngradePolling({ keepalive, downgradePolling, }) {
+        return keepalive
+            ? downgradePolling
+            : this.pageVisibility
+                .getPageVisibility()
+                .pipe(map(visible => (visible ? downgradePolling : 0)));
+    }
+    static { this.ɵfac = function K8sApiService_Factory(t) { return new (t || K8sApiService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.K8sApiResourceService), i0.ɵɵinject(i3.PageVisibilityService), i0.ɵɵinject(TOKEN_GLOBAL_NAMESPACE)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: K8sApiService, factory: K8sApiService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(K8sApiService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.K8sApiResourceService }, { type: i3.PageVisibilityService }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [TOKEN_GLOBAL_NAMESPACE]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"k8s-api.service.js","sourceRoot":"","sources":["../../../../../libs/common/src/api/k8s-api.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module api\n */\n\nimport {\n  HttpClient,\n  HttpDownloadProgressEvent,\n  HttpEventType,\n} from '@angular/common/http';\nimport { Inject, Injectable } from '@angular/core';\nimport { get, isEqual, set } from 'lodash-es';\nimport {\n  NEVER,\n  Observable,\n  Subscription,\n  combineLatest,\n  from,\n  of,\n  throwError,\n  filter,\n  map,\n  retryWhen,\n  startWith,\n  switchMap,\n  concatMap,\n  delay,\n  distinctUntilChanged,\n} from 'rxjs';\n\nimport {\n  CRYPTO_HEADER_KEY,\n  KubernetesResource,\n  KubernetesResourceList,\n  Status,\n} from '../core';\nimport {\n  API_GATEWAY,\n  DOWNGRADE_WATCH_ENABLED,\n  NOTIFY_ON_ERROR_HEADERS,\n  NOT_NOTIFY_ON_ERROR_HEADERS,\n  TRUE,\n} from '../core/constants/constants';\nimport { TOKEN_GLOBAL_NAMESPACE } from '../core/constants/tokens';\nimport { METADATA, NAME, NAMESPACE } from '../core/services';\nimport { parseJSONStream } from '../core/utils';\nimport { createPollObservable } from '../core/utils/observable';\nimport { normalizeParams } from '../k8s-resource-list/utils';\n\nimport {\n  getApiPrefixParts,\n  getMetadataHeaders,\n  isResourceEvent,\n  reduceWatchEvents,\n} from './helpers';\nimport { K8sApiResourceService } from './k8s-api-resource.service';\nimport { PageVisibilityService } from './page-visibility.service';\nimport {\n  ApiBaseParams,\n  ErebusResourceDeleteParams,\n  ErebusResourceListParams,\n  ErebusResourceParams,\n  ErebusResourcePatchParams,\n  ErebusResourceWriteParams,\n  GlobalResourceDeleteParams,\n  GlobalResourceListParams,\n  GlobalResourceParams,\n  GlobalResourcePatchParams,\n  GlobalResourceWriteParams,\n  PatchOperation,\n  ResourceApiParams,\n  ResourceDeleteParams,\n  ResourceListReadParams,\n  ResourcePatchParams,\n  ResourceReadParams,\n  ResourceWriteParams,\n  WatchAPIResponse,\n  WatchApiParams,\n  WatchErebusResourceListParams,\n  WatchErebusResourceParams,\n  WatchEvent,\n  WatchGlobalResourceListParams,\n  WatchGlobalResourceParams,\n  WatchResourceListReadParams,\n  WatchResourceReadParams,\n  ErebusResourceBatchDeleteParams,\n} from './types';\n\n// 名称前缀 Erebus 参考 http://confluence.alauda.cn/pages/viewpage.action?pageId=44663484 指 /kubernetes/ 开头的 api 组件\n\nexport const TIMEOUT_SECONDS = 59;\nexport const SEARCH_URL_PREFIX = '/acp/v1/resources/search';\n\nconst RETRY_DELAY = 5000;\n\nconst RETRY_COUNT = 3;\n\n@Injectable({ providedIn: 'root' })\nexport class K8sApiService<R extends string = string> {\n  constructor(\n    private readonly http: HttpClient,\n    private readonly k8sApiResource: K8sApiResourceService,\n    private readonly pageVisibility: PageVisibilityService,\n    @Inject(TOKEN_GLOBAL_NAMESPACE) private readonly globalNamespace: string,\n  ) {}\n\n  /**\n   * 获取 Global 集群单个资源对象\n   */\n  getGlobalResource<T extends KubernetesResource>(\n    params: GlobalResourceParams<R>,\n  ) {\n    return this._getResource<T>(params);\n  }\n\n  /**\n   * 监听 Global 集群单个资源对象\n   */\n  watchGlobalResource<T extends KubernetesResource>(\n    params: WatchGlobalResourceParams<R>,\n  ) {\n    return DOWNGRADE_WATCH_ENABLED && params.downgradePolling\n      ? createPollObservable<T>(\n          this.getGlobalResource(params),\n          this._getDowngradePolling(params),\n        ).pipe(distinctUntilChanged((a, b) => isEqual(a, b)))\n      : this._watchResource<T>(params);\n  }\n\n  /**\n   * 监听 Global 集群资源列表变化\n   */\n  watchGlobalResourceChange<T extends KubernetesResource>(\n    seedVersion: string,\n    params: WatchGlobalResourceListParams<R>,\n  ) {\n    return this._keepWatchResourceChange<T>(seedVersion, params);\n  }\n\n  /**\n   * 获取 Global 集群资源对象列表，包含分页信息\n   */\n  getGlobalResourceList<T extends KubernetesResource>(\n    params: GlobalResourceListParams<R>,\n  ) {\n    return this._getResourceList<T>(params);\n  }\n\n  /**\n   * 创建 Global 集群资源\n   */\n  postGlobalResource<T extends KubernetesResource>(\n    params: GlobalResourceWriteParams<T, R>,\n  ) {\n    return this._postResource<T>(params);\n  }\n\n  /**\n   * 完整覆盖更新 Global 集群单个资源对象\n   */\n  putGlobalResource<T extends KubernetesResource>(\n    params: GlobalResourceWriteParams<T, R>,\n  ) {\n    return this._putResource<T>(params);\n  }\n\n  /**\n   * 增量更新 Global 集群单个资源对象的部分属性\n   */\n  patchGlobalResource<T extends KubernetesResource>(\n    params: GlobalResourcePatchParams<T, R>,\n  ) {\n    return this._patchResource<T>(params);\n  }\n\n  /**\n   * 删除 Global 集群单个资源\n   */\n  deleteGlobalResource<\n    S extends KubernetesResource = Status,\n    T extends KubernetesResource = S extends Status ? KubernetesResource : S,\n  >(params: GlobalResourceDeleteParams<T, R>) {\n    return this._deleteResource<S, T>(params);\n  }\n\n  /**\n   * 获取业务集群单个资源对象\n   */\n  getResource<T extends KubernetesResource>(params: ErebusResourceParams<R>) {\n    return this._getResource<T>(params);\n  }\n\n  /**\n   * 监听业务集群单个资源对象\n   */\n  watchResource<T extends KubernetesResource>(\n    params: WatchErebusResourceParams<R>,\n  ) {\n    return DOWNGRADE_WATCH_ENABLED && params.downgradePolling\n      ? createPollObservable<T>(\n          this._getResource<T>(params),\n          this._getDowngradePolling(params),\n        ).pipe(distinctUntilChanged((a, b) => isEqual(a, b)))\n      : this._watchResource<T>(params);\n  }\n\n  /**\n   * 监听资源列表变化\n   */\n  watchResourceChange<T extends KubernetesResource>(\n    seedVersion: string,\n    params: WatchErebusResourceListParams<R>,\n  ) {\n    return this._keepWatchResourceChange<T>(seedVersion, params);\n  }\n\n  /**\n   * 获取业务集群资源对象列表，包含分页信息\n   */\n  getResourceList<T extends KubernetesResource>(\n    params: ErebusResourceListParams<R>,\n  ) {\n    return this._getResourceList<T>(params);\n  }\n\n  /**\n   * 创建业务集群资源\n   */\n  postResource<T extends KubernetesResource>(\n    params: ErebusResourceWriteParams<T, R>,\n  ) {\n    return this._postResource<T>(params);\n  }\n\n  /**\n   * 完整覆盖更新业务集群单个资源对象\n   */\n  putResource<T extends KubernetesResource>(\n    params: ErebusResourceWriteParams<T, R>,\n  ) {\n    return this._putResource<T>(params);\n  }\n\n  /**\n   * 增量更新业务集群单个资源对象的部分属性\n   */\n  patchResource<T extends KubernetesResource>(\n    params: ErebusResourcePatchParams<T, R>,\n  ) {\n    return this._patchResource<T>(params);\n  }\n\n  /**\n   * 删除业务集群单个资源\n   */\n  deleteResource<\n    S extends KubernetesResource = Status,\n    T extends KubernetesResource = S extends Status ? KubernetesResource : S,\n  >(params: ErebusResourceDeleteParams<T, R>) {\n    if ('name' in params && !params.name) {\n      return throwError(() => new Error('delete resource need resource name'));\n    }\n    return this._deleteResource<S, T>(params);\n  }\n\n  /**\n   * 批量删除业务集群的资源\n   */\n  batchDeleteResource<\n    S extends KubernetesResource = Status,\n    T extends KubernetesResource = S extends Status ? KubernetesResource : S,\n  >(params: ErebusResourceBatchDeleteParams<R>) {\n    return this._batchDeleteResource<T>(params);\n  }\n\n  // @internal\n  private _getResourceDefinition(params: ResourceApiParams<R>) {\n    const definition = this.k8sApiResource.getDefinition(\n      'definition' in params && params.definition\n        ? params.definition\n        : 'type' in params && params.type,\n    );\n    if ('resource' in params && params.resource) {\n      return {\n        type: definition.type,\n        ...getApiPrefixParts(params.resource.apiVersion),\n      };\n    }\n    return definition;\n  }\n\n  // @internal\n  private _getApiPath(params: ResourceApiParams<R>, ignoreName = false) {\n    return this.k8sApiResource.getApiPath({\n      ...this._getResourceDefinition(params),\n      cluster: 'cluster' in params && params.cluster,\n      namespace: this._getNamespace(params),\n      name: ignoreName ? null : this._getName(params),\n    });\n  }\n\n  // @internal\n  private _getNamespace(params: ResourceApiParams<R>) {\n    return 'namespace' in params && params.namespace\n      ? params.namespace\n      : 'namespaced' in params && params.namespaced\n      ? this.globalNamespace\n      : 'resource' in params && get(params.resource, [METADATA, NAMESPACE]);\n  }\n\n  // @internal\n  private _getName(params: ResourceApiParams<R>) {\n    return 'name' in params\n      ? params.name\n      : 'resource' in params && get(params.resource, [METADATA, NAME]);\n  }\n\n  /**\n   * k8s list api 返回的结果里，items 缺失 kind 和 apiVersion 字段\n   * 规则如 Service 类型对应 kind: ServiceList，去掉最后四个字符可得到资源的 kind\n   * @internal\n   */\n  private _getNormalizedList<T extends KubernetesResourceList>(list: T): T {\n    const { apiVersion, items } = list;\n\n    if (!items || items.length === 0) {\n      return {\n        ...list,\n        items: [],\n      };\n    }\n\n    const kind = list.kind.slice(0, -4);\n    return {\n      ...list,\n      items: items.map(item => ({\n        // key 顺序会影响转 yaml 后的顺序\n        kind,\n        apiVersion,\n        ...item,\n      })),\n    };\n  }\n\n  // @internal\n  private _getResource<T extends KubernetesResource>(\n    params: ResourceReadParams<R>,\n  ) {\n    return this.http.get<T>(this._getApiPath(params), {\n      headers: this._getHeaders(params),\n    });\n  }\n\n  // @internal\n  private _watchResource<T extends KubernetesResource>(\n    params: WatchResourceReadParams<R>,\n  ) {\n    const detailParams = {\n      ...params,\n      queryParams: { fieldSelector: 'metadata.name=' + this._getName(params) },\n    };\n    const defaultRetry = {\n      count: RETRY_COUNT,\n      delay: RETRY_DELAY,\n    };\n    const { count, delay: delayTime } =\n      params.retry === true\n        ? {\n            ...defaultRetry,\n            count: Infinity,\n          }\n        : {\n            ...defaultRetry,\n            ...params.retry,\n          };\n    let soFar = 0;\n    return this._getResourceList<T>(detailParams).pipe(\n      switchMap(list =>\n        this._keepWatchResourceChange<T>(\n          list.metadata.resourceVersion,\n          detailParams,\n        ).pipe(\n          filter(isResourceEvent),\n          map(res => (res.type === WatchEvent.Deleted ? null : res.object)),\n          startWith(list.items[0] ?? null),\n        ),\n      ),\n      retryWhen(err$ =>\n        err$.pipe(\n          switchMap(err => {\n            if (err === WatchEvent.Error || (count && soFar++ < count)) {\n              return of(err).pipe(delay(count ? delayTime : 0));\n            }\n            return throwError(() => err);\n          }),\n        ),\n      ),\n    );\n  }\n\n  // @internal\n  private _keepWatchResourceChange<T extends KubernetesResource>(\n    seedVersion: string,\n    params: WatchResourceListReadParams<R>,\n  ) {\n    let resourceVersion = seedVersion;\n    let sub: Subscription;\n\n    const watch$ = new Observable<WatchAPIResponse<T>>(observer => {\n      const unsubscribe = () => {\n        if (sub && !sub.closed) {\n          sub.unsubscribe();\n        }\n      };\n\n      const watch = () => {\n        unsubscribe();\n        sub = this._watchResourceChange<T>({\n          ...params,\n          queryParams: normalizeParams({\n            ...params.queryParams,\n            watch: TRUE,\n            allowWatchBookmarks: TRUE,\n            timeoutSeconds: String(TIMEOUT_SECONDS),\n            resourceVersion,\n          }),\n        }).subscribe({\n          next(res) {\n            if (res.type === WatchEvent.Error) {\n              observer.error(res.type);\n              return;\n            }\n\n            resourceVersion = res.object.metadata.resourceVersion;\n            observer.next(res);\n          },\n          error(err) {\n            observer.error(err);\n          },\n          complete: watch,\n        });\n      };\n\n      watch();\n      return unsubscribe;\n    });\n\n    return params.keepalive\n      ? watch$\n      : combineLatest([\n          this.pageVisibility.getPageVisibility(),\n          params.active$ || of(true),\n        ]).pipe(\n          switchMap(([visible, active]) =>\n            visible && active ? watch$ : NEVER,\n          ),\n        );\n  }\n\n  // @internal\n  private _watchResourceChange<T extends KubernetesResource>(\n    params: ResourceListReadParams<R>,\n  ): Observable<WatchAPIResponse<T>> {\n    return this.http\n      .get(this._getApiPath(params, true), {\n        responseType: 'text',\n        observe: 'events',\n        reportProgress: true,\n        headers: this._getHeaders(params),\n        params: params.queryParams,\n      })\n      .pipe(\n        filter(ev => ev.type === HttpEventType.DownloadProgress),\n        filter(\n          ({ partialText }: HttpDownloadProgressEvent) => !!partialText?.trim(),\n        ),\n        concatMap(({ partialText }) =>\n          from(\n            reduceWatchEvents(\n              parseJSONStream<WatchAPIResponse<T>>(partialText),\n            ),\n          ),\n        ),\n      );\n  }\n\n  // @internal\n  private _getResourceList<T extends KubernetesResource>(\n    params: ResourceListReadParams<R>,\n  ) {\n    // 包含 keyword 前缀需要加上前缀 'acp/v1/resources/search'\n    // 参考 http://confluence.alauda.cn/pages/viewpage.action?pageId=48731058\n    let url = this._getApiPath(params, true);\n    const queryParams = { ...params.queryParams };\n    if (queryParams.keyword) {\n      url = url.replace(API_GATEWAY, `${API_GATEWAY}${SEARCH_URL_PREFIX}`);\n      if (!queryParams.field) {\n        queryParams.field = 'metadata.name';\n      }\n    }\n    return this.http\n      .get<KubernetesResourceList<T>>(url, {\n        params: queryParams,\n        headers: this._getHeaders(params, true),\n      })\n      .pipe(map(this._getNormalizedList));\n  }\n\n  // @internal\n  private _postResource<T extends KubernetesResource>(\n    params: ResourceWriteParams<R, T>,\n  ) {\n    if (\n      ('namespace' in params && params.namespace) ||\n      ('namespaced' in params && params.namespaced)\n    ) {\n      const resourceNamespace = get(params.resource, [METADATA, NAMESPACE]);\n      if (!resourceNamespace) {\n        set(\n          params.resource,\n          [METADATA, NAMESPACE],\n          params.namespace || this.globalNamespace,\n        );\n      }\n    }\n    return this.http.post<T>(this._getApiPath(params, true), params.resource, {\n      headers: this._getHeaders(params),\n    });\n  }\n\n  // @internal\n  private _putResource<T extends KubernetesResource>(\n    params: ResourceWriteParams<R, T>,\n  ) {\n    return this.http.put<T>(this._getApiPath(params), params.resource, {\n      headers: this._getHeaders(params),\n    });\n  }\n\n  // @internal\n  private _patchResource<T extends KubernetesResource>(\n    params: ResourcePatchParams<R, T>,\n  ) {\n    return this.http.patch<T>(this._getApiPath(params), params.part, {\n      headers: {\n        ...this._getHeaders(params),\n        'Content-Type': params.operation || PatchOperation.Merge,\n      },\n    });\n  }\n\n  // @internal\n  private _deleteResource<\n    S extends KubernetesResource,\n    T extends KubernetesResource,\n  >(params: ResourceDeleteParams<R, T>) {\n    return this.http.request<S>('delete', this._getApiPath(params), {\n      headers: this._getHeaders(params),\n      body: params.body,\n    });\n  }\n\n  // @internal\n  private _batchDeleteResource<S extends KubernetesResource>(\n    params: ErebusResourceBatchDeleteParams<R>,\n  ) {\n    return this.http.request<S>('delete', this._getApiPath(params), {\n      headers: this._getHeaders(params),\n      body: params.body,\n      params: params.queryParams,\n    });\n  }\n\n  // @internal\n  private readonly _getHeaders = (\n    { notifyOnError, onlyMetadata, customAccept, crypto }: ApiBaseParams<R>,\n    isList?: boolean,\n  ) => {\n    const headers: Record<string, string | string[]> = {};\n    if (typeof notifyOnError === 'boolean') {\n      Object.assign(\n        headers,\n        notifyOnError ? NOTIFY_ON_ERROR_HEADERS : NOT_NOTIFY_ON_ERROR_HEADERS,\n      );\n    }\n    if (crypto) {\n      Object.assign(headers, {\n        [CRYPTO_HEADER_KEY]: crypto,\n      });\n    }\n    /**\n     * @see https://github.com/kubernetes/design-proposals-archive/blob/main/api-machinery/alternate-api-representations.md\n     */\n    if (onlyMetadata) {\n      Object.assign(headers, getMetadataHeaders(isList, customAccept));\n    }\n    return headers;\n  };\n\n  private _getDowngradePolling({\n    keepalive,\n    downgradePolling,\n  }: WatchApiParams) {\n    return keepalive\n      ? downgradePolling\n      : this.pageVisibility\n          .getPageVisibility()\n          .pipe(map(visible => (visible ? downgradePolling : 0)));\n  }\n}\n"]}