@dovetail-v2/refine 0.0.66-pod-exec.0 → 0.1.0

package/lib/src/locales/zh-CN/dovetail.json

@@ -0,0 +1,91 @@
+{
+    "copy": "复制",
+    "reset_arguments": "重置",
+    "view_changes": "查看改动",
+    "back_to_edit": "编辑",
+    "configure_file": "配置内容",
+    "yaml_format_wrong": "配置内容不是有效的 yaml 格式。",
+    "yaml_value_wrong": "配置内容中存在不合法的值。",
+    "edit_yaml": "编辑 YAML",
+    "copied": "已复制",
+    "already_reset": "已重置",
+    "cancel": "取消",
+    "delete": "删除",
+    "create": "创建",
+    "confirm_delete_text": "确定要删除 {{target}} 吗？",
+    "edit": "编辑",
+    "namespace": "名字空间",
+    "name": "名称",
+    "state": "状态",
+    "status": "状态",
+    "phase": "状态",
+    "image": "容器镜像",
+    "replicas": "副本数",
+    "created_time": "创建时间",
+    "label": "标签",
+    "annotation": "注释",
+    "type": "类型",
+    "event": "事件",
+    "reason": "原因",
+    "object": "对象",
+    "note": "事件信息",
+    "condition": "Condition",
+    "download_yaml": "下载 YAML",
+    "detail": "详情",
+    "node_name": "主机名称",
+    "restarts": "重启次数",
+    "updated_time": "更新时间",
+    "message": "消息",
+    "save": "保存",
+    "more": "更多",
+    "workload": "工作负载",
+    "all_namespaces": "所有名字空间",
+    "empty": "无可显示的数据",
+    "schedule": "调度时间表",
+    "lastScheduleTime": "上次调度时间",
+    "duration": "持续时间",
+    "completions": "完成 Job 历史数",
+    "started": "开始时间",
+    "init_container": "初始化容器",
+    "container": "容器",
+    "redeploy": "重新部署",
+    "data": "数据",
+    "suspend": "暂停",
+    "resume": "重新开始",
+    "cluster": "集群",
+    "storage": "存储",
+    "network": "网络",
+    "clusterIp": "集群 IP",
+    "sessionAffinity": "会话保持",
+    "log": "日志",
+    "select_container": "选择容器",
+    "wrap": "折叠",
+    "resume_log": "继续",
+    "log_new_lines": "，并展示 {{ count }} 行新日志",
+    "fetch_schema_fail": "获取 schema 失败。",
+    "obtain_data_error": "获取数据时遇到问题。",
+    "retry": "重试",
+    "ready": "就绪",
+    "updating": "更新中",
+    "completed": "完成",
+    "failed": "异常",
+    "suspended": "挂起",
+    "running": "运行中",
+    "terminating": "终止",
+    "succeeded": "成功终止",
+    "unknown": "未知",
+    "pending": "待处理",
+    "waiting": "等待中",
+    "create_resource": "创建 {{resource}}",
+    "edit_resource": "编辑 {{resource}}",
+    "sec": "秒",
+    "min": "分",
+    "hr": "小时",
+    "day": "天",
+    "expand": "展开",
+    "fold": "收起",
+    "rule": "规则",
+    "default_backend": "默认后端",
+    "ingress_rule_type": "规则类型",
+    "port": "端口"
+}

package/lib/src/locales/zh-CN/index.d.ts

@@ -155,10 +155,21 @@ declare const _default: {
         only_support_one_yaml: string;
         not_support: string;
         stopped: string;
+        any_node_ip: string;
         storage_class: string;
-        persistent_volumn: string;
+        persistent_volume: string;
         provisioner: string;
         file_system: string;
+        capacity: string;
+        phase: string;
+        volume_mode: string;
+        access_mode: string;
+        block: string;
+        pv_phase_available: string;
+        pv_phase_bound: string;
+        pv_phase_released: string;
+        pv_phase_failed: string;
+        pv_phase_pending: string;
     };
 };
 export default _default;

package/lib/src/locales/zh-CN/index.js

@@ -0,0 +1,4 @@
+import dovetail from './dovetail.json';
+export default {
+    dovetail,
+};

package/lib/src/main.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { initParrotI18n } from '@cloudtower/eagle';
+import React from 'react';
+// eslint-disable-next-line react/no-deprecated
+import { render } from 'react-dom';
+import App from './App';
+import './i18n';
+import 'antd/dist/antd.css';
+import '@cloudtower/eagle/dist/style.css';
+initParrotI18n();
+const container = document.getElementById('root');
+render(_jsx(React.StrictMode, { children: _jsx(React.Suspense, { fallback: "loading", children: _jsx(App, {}) }) }), container);

package/lib/src/models/cronjob-model.d.ts

@@ -5,7 +5,6 @@ import { WorkloadBaseModel } from './workload-base-model';
 type RequiredCronJob = Required<CronJob> & Unstructured;
 export declare class CronJobModel extends WorkloadBaseModel {
     _rawYaml: RequiredCronJob;
-    _globalStore: GlobalStore;
     spec?: RequiredCronJob['spec'];
     status?: RequiredCronJob['status'];
     constructor(_rawYaml: RequiredCronJob, _globalStore: GlobalStore);

package/lib/src/models/cronjob-model.js

@@ -0,0 +1,32 @@
+import { set, cloneDeep } from 'lodash';
+import { WorkloadState } from '../constants';
+import { WorkloadBaseModel } from './workload-base-model';
+export class CronJobModel extends WorkloadBaseModel {
+    _rawYaml;
+    _globalStore;
+    constructor(_rawYaml, _globalStore) {
+        super(_rawYaml, _globalStore);
+        this._rawYaml = _rawYaml;
+        this._globalStore = _globalStore;
+    }
+    get stateDisplay() {
+        if (!this.spec?.suspend) {
+            return WorkloadState.SUSPENDED;
+        }
+        return WorkloadState.RUNNING;
+    }
+    suspend() {
+        const newOne = cloneDeep(this._rawYaml);
+        if (this._rawYaml.kind === 'CronJob') {
+            set(newOne, 'spec.suspend', true);
+        }
+        return newOne;
+    }
+    resume() {
+        const newOne = cloneDeep(this._rawYaml);
+        if (this._rawYaml.kind === 'CronJob') {
+            set(newOne, 'spec.suspend', false);
+        }
+        return newOne;
+    }
+}

package/lib/src/models/daemonset-model.d.ts

@@ -5,7 +5,6 @@ import { WorkloadModel } from './workload-model';
 type RequiredDaemonSet = Required<DaemonSet> & Unstructured;
 export declare class DaemonSetModel extends WorkloadModel {
     _rawYaml: RequiredDaemonSet;
-    _globalStore: GlobalStore;
     spec?: RequiredDaemonSet['spec'];
     status?: RequiredDaemonSet['status'];
     constructor(_rawYaml: RequiredDaemonSet, _globalStore: GlobalStore);

package/lib/src/models/daemonset-model.js

@@ -0,0 +1,17 @@
+import { WorkloadState } from '../constants';
+import { WorkloadModel } from './workload-model';
+export class DaemonSetModel extends WorkloadModel {
+    _rawYaml;
+    _globalStore;
+    constructor(_rawYaml, _globalStore) {
+        super(_rawYaml, _globalStore);
+        this._rawYaml = _rawYaml;
+        this._globalStore = _globalStore;
+    }
+    get stateDisplay() {
+        if (this.status?.desiredNumberScheduled !== this.status?.numberReady) {
+            return WorkloadState.UPDATEING;
+        }
+        return WorkloadState.READY;
+    }
+}

package/lib/src/models/deployment-model.d.ts

@@ -5,7 +5,6 @@ import { WorkloadModel } from './workload-model';
 type RequiredDeployment = Required<Deployment> & Unstructured;
 export declare class DeploymentModel extends WorkloadModel {
     _rawYaml: RequiredDeployment;
-    _globalStore: GlobalStore;
     spec?: RequiredDeployment['spec'];
     status?: RequiredDeployment['status'];
     constructor(_rawYaml: RequiredDeployment, _globalStore: GlobalStore);

package/lib/src/models/deployment-model.js

@@ -0,0 +1,17 @@
+import { WorkloadState } from '../constants';
+import { WorkloadModel } from './workload-model';
+export class DeploymentModel extends WorkloadModel {
+    _rawYaml;
+    _globalStore;
+    constructor(_rawYaml, _globalStore) {
+        super(_rawYaml, _globalStore);
+        this._rawYaml = _rawYaml;
+        this._globalStore = _globalStore;
+    }
+    get stateDisplay() {
+        if (this.spec?.replicas !== this.status?.readyReplicas) {
+            return WorkloadState.UPDATEING;
+        }
+        return WorkloadState.READY;
+    }
+}

package/lib/src/models/event-model.d.ts

@@ -3,6 +3,5 @@ import { Event } from 'kubernetes-types/core/v1';
 import { ResourceModel } from './resource-model';
 export declare class EventModel extends ResourceModel {
     _rawYaml: Unstructured & Event;
-    _globalStore: GlobalStore;
     constructor(_rawYaml: Unstructured & Event, _globalStore: GlobalStore);
 }

package/lib/src/models/event-model.js

@@ -0,0 +1,11 @@
+import { ResourceModel } from './resource-model';
+export class EventModel extends ResourceModel {
+    _rawYaml;
+    _globalStore;
+    constructor(_rawYaml, _globalStore) {
+        super(_rawYaml, _globalStore);
+        this._rawYaml = _rawYaml;
+        this._globalStore = _globalStore;
+        this.id = _rawYaml.metadata.uid || _rawYaml.id;
+    }
+}

package/lib/src/models/index.js

@@ -0,0 +1,14 @@
+export * from './ingress-model';
+export * from './network-policy-model';
+export * from './job-model';
+export * from './workload-model';
+export * from './workload-base-model';
+export * from './pod-model';
+export * from './pod-metrics-model';
+export * from './resource-model';
+export * from './workload-model';
+export * from './cronjob-model';
+export * from './event-model';
+export * from './deployment-model';
+export * from './daemonset-model';
+export * from './statefulset-model';

package/lib/src/models/ingress-model.d.ts

@@ -12,7 +12,6 @@ export type RuleItem = {
 };
 export declare class IngressModel extends ResourceModel<IngressTypes> {
     _rawYaml: IngressTypes;
-    _globalStore: GlobalStore;
     flattenedRules: RuleItem[];
     constructor(_rawYaml: IngressTypes, _globalStore: GlobalStore);
     init(): Promise<void>;

package/lib/src/models/ingress-model.js

@@ -0,0 +1,24 @@
+import { ResourceModel } from './resource-model';
+export class IngressModel extends ResourceModel {
+    _rawYaml;
+    _globalStore;
+    flattenedRules;
+    constructor(_rawYaml, _globalStore) {
+        super(_rawYaml, _globalStore);
+        this._rawYaml = _rawYaml;
+        this._globalStore = _globalStore;
+        this.flattenedRules =
+            this._rawYaml.spec.rules?.reduce((res, rule) => {
+                const paths = rule.http?.paths.map(p => {
+                    return {
+                        serviceName: p.backend.service?.name || '',
+                        fullPath: rule.host ? `${rule.host}${p.path}` : p.path || '',
+                        pathType: p.pathType,
+                        servicePort: p.backend.service?.port?.number,
+                        host: rule.host,
+                    };
+                });
+                return [...res, ...(paths || [])];
+            }, []) || [];
+    }
+}

package/lib/src/models/job-model.d.ts

@@ -5,7 +5,6 @@ import { WorkloadBaseModel } from './workload-base-model';
 type RequiredJob = Required<Job> & Unstructured;
 export declare class JobModel extends WorkloadBaseModel {
     _rawYaml: RequiredJob;
-    _globalStore: GlobalStore;
     restarts: number;
     spec?: RequiredJob['spec'];
     status?: RequiredJob['status'];

package/lib/src/models/job-model.js

@@ -0,0 +1,56 @@
+import { sumBy } from 'lodash';
+import { WorkloadState } from '../constants';
+import { matchSelector } from '../utils/match-selector';
+import { getSecondsDiff } from '../utils/time';
+import { WorkloadBaseModel } from './workload-base-model';
+export class JobModel extends WorkloadBaseModel {
+    _rawYaml;
+    _globalStore;
+    restarts = 0;
+    constructor(_rawYaml, _globalStore) {
+        super(_rawYaml, _globalStore);
+        this._rawYaml = _rawYaml;
+        this._globalStore = _globalStore;
+    }
+    async init() {
+        await this.getRestarts();
+    }
+    async getRestarts() {
+        const pods = (await this._globalStore.get('pods', {
+            resourceBasePath: '/api/v1',
+            kind: 'Pod',
+        }));
+        const myPods = pods.items.filter(p => this.spec?.selector ? matchSelector(p, this.spec?.selector) : false);
+        const result = sumBy(myPods, 'restartCount');
+        this.restarts = result;
+    }
+    get duration() {
+        const completionTime = this._rawYaml.status?.completionTime;
+        const startTime = this._rawYaml.status?.startTime;
+        if (!completionTime && startTime) {
+            return getSecondsDiff(startTime, Date.now().toString());
+        }
+        if (completionTime && startTime) {
+            return getSecondsDiff(startTime, completionTime);
+        }
+        return 0;
+    }
+    get completionsDisplay() {
+        return `${this._rawYaml.status?.succeeded || 0}/${this._rawYaml.spec?.completions}`;
+    }
+    get stateDisplay() {
+        if (!this.spec?.completions && !this.status?.succeeded) {
+            return WorkloadState.RUNNING;
+        }
+        if (this.spec?.completions === this.status?.succeeded) {
+            return WorkloadState.COMPLETED;
+        }
+        if (this.status?.conditions?.some(c => c.type === 'Failed' && c.status === 'True')) {
+            return WorkloadState.FAILED;
+        }
+        if (this.status?.conditions?.some(c => c.type === 'Suspended' && c.status === 'True')) {
+            return WorkloadState.SUSPENDED;
+        }
+        return WorkloadState.RUNNING;
+    }
+}

package/lib/src/models/network-policy-model.d.ts

@@ -4,7 +4,6 @@ import { ResourceModel } from './resource-model';
 type NetworkPolicyTypes = Required<NetworkPolicy> & Unstructured;
 export declare class NetworkPolicyModel extends ResourceModel<NetworkPolicyTypes> {
     _rawYaml: NetworkPolicyTypes;
-    _globalStore: GlobalStore;
     constructor(_rawYaml: NetworkPolicyTypes, _globalStore: GlobalStore);
 }
 export {};

package/lib/src/models/network-policy-model.js

@@ -0,0 +1,10 @@
+import { ResourceModel } from './resource-model';
+export class NetworkPolicyModel extends ResourceModel {
+    _rawYaml;
+    _globalStore;
+    constructor(_rawYaml, _globalStore) {
+        super(_rawYaml, _globalStore);
+        this._rawYaml = _rawYaml;
+        this._globalStore = _globalStore;
+    }
+}

package/lib/src/models/node-model.d.ts

@@ -8,7 +8,6 @@ export declare enum NodeRole {
 }
 export declare class NodeModel extends WorkloadBaseModel {
     _rawYaml: RequiredNode;
-    _globalStore: GlobalStore;
     constructor(_rawYaml: RequiredNode, _globalStore: GlobalStore);
     get role(): NodeRole;
     get ip(): string | undefined;

package/lib/src/models/persistent-volume-claim.d.ts

@@ -4,7 +4,6 @@ import { ResourceModel } from './resource-model';
 type RequiredPersistentClaimVolume = Required<PersistentVolumeClaim> & Unstructured;
 export declare class PersistentVolumeClaimModel extends ResourceModel {
     _rawYaml: RequiredPersistentClaimVolume;
-    _globalStore: GlobalStore;
     constructor(_rawYaml: RequiredPersistentClaimVolume, _globalStore: GlobalStore);
 }
 export {};

package/lib/src/models/persistent-volume.d.ts

@@ -4,7 +4,6 @@ import { ResourceModel } from './resource-model';
 type RequiredPersistentVolume = Required<PersistentVolume> & Unstructured;
 export declare class PersistentVolumeModel extends ResourceModel {
     _rawYaml: RequiredPersistentVolume;
-    _globalStore: GlobalStore;
     constructor(_rawYaml: RequiredPersistentVolume, _globalStore: GlobalStore);
 }
 export {};

package/lib/src/models/pod-metrics-model.d.ts

@@ -3,7 +3,6 @@ import { ResourceModel } from './resource-model';
 import { PodMetrics, ResourceQuantity } from './types/metric';
 export declare class PodMetricsModel extends ResourceModel<PodMetrics> {
     _rawYaml: PodMetrics;
-    _globalStore: GlobalStore;
     usage: ResourceQuantity;
     constructor(_rawYaml: PodMetrics, _globalStore: GlobalStore);
 }

package/lib/src/models/pod-metrics-model.js

@@ -0,0 +1,34 @@
+import { formatSi, parseSi } from '../utils/unit';
+import { ResourceModel } from './resource-model';
+export class PodMetricsModel extends ResourceModel {
+    _rawYaml;
+    _globalStore;
+    usage;
+    constructor(_rawYaml, _globalStore) {
+        super(_rawYaml, _globalStore);
+        this._rawYaml = _rawYaml;
+        this._globalStore = _globalStore;
+        let cpuUsageNum = 0;
+        let memoryUsageNum = 0;
+        for (const container of _rawYaml.containers) {
+            cpuUsageNum += parseSi(container.usage.cpu || '0');
+            memoryUsageNum += parseSi(container.usage.memory || '0');
+        }
+        this.usage = {
+            cpu: {
+                value: cpuUsageNum,
+                si: formatSi(1000 * cpuUsageNum, {
+                    suffix: 'm',
+                    maxPrecision: 0,
+                }),
+            },
+            memory: {
+                value: memoryUsageNum,
+                si: formatSi(memoryUsageNum, {
+                    suffix: 'i',
+                    maxPrecision: 0,
+                }),
+            },
+        };
+    }
+}

package/lib/src/models/pod-model.d.ts

@@ -5,7 +5,6 @@ import { WorkloadBaseModel } from './workload-base-model';
 type RequiredPod = Required<Pod> & Unstructured;
 export declare class PodModel extends WorkloadBaseModel {
     _rawYaml: RequiredPod;
-    _globalStore: GlobalStore;
     request: ResourceQuantity;
     limit: ResourceQuantity;
     spec?: RequiredPod['spec'];

package/lib/src/models/pod-model.js

@@ -0,0 +1,78 @@
+import { WorkloadState } from '../constants';
+import { shortenedImage } from '../utils/string';
+import { formatSi, parseSi } from '../utils/unit';
+import { WorkloadBaseModel } from './workload-base-model';
+export class PodModel extends WorkloadBaseModel {
+    _rawYaml;
+    _globalStore;
+    request;
+    limit;
+    constructor(_rawYaml, _globalStore) {
+        super(_rawYaml, _globalStore);
+        this._rawYaml = _rawYaml;
+        this._globalStore = _globalStore;
+        let cpuRequestNum = 0;
+        let memoryRequestNum = 0;
+        let cpuLimitNum = 0;
+        let memoryLimitNum = 0;
+        for (const container of _rawYaml.spec?.containers || []) {
+            cpuRequestNum += parseSi(container.resources?.requests?.cpu || '0');
+            memoryRequestNum += parseSi(container.resources?.requests?.memory || '0');
+            cpuLimitNum += parseSi(container.resources?.limits?.cpu || '0');
+            memoryLimitNum += parseSi(container.resources?.limits?.memory || '0');
+        }
+        this.request = {
+            cpu: {
+                value: cpuRequestNum,
+                si: formatSi(cpuRequestNum, {
+                    suffix: 'm',
+                }),
+            },
+            memory: {
+                value: memoryRequestNum,
+                si: formatSi(memoryRequestNum, {
+                    suffix: 'i',
+                }),
+            },
+        };
+        this.limit = {
+            cpu: {
+                value: cpuLimitNum,
+                si: formatSi(cpuLimitNum, {
+                    suffix: 'm',
+                }),
+            },
+            memory: {
+                value: memoryLimitNum,
+                si: formatSi(memoryLimitNum, {
+                    suffix: 'i',
+                }),
+            },
+        };
+    }
+    get imageNames() {
+        return (this._rawYaml.spec?.containers.map(container => shortenedImage(container.image || '')) || []);
+    }
+    get restartCount() {
+        if (this._rawYaml.status?.containerStatuses) {
+            return this._rawYaml.status?.containerStatuses[0].restartCount || 0;
+        }
+        return 0;
+    }
+    get readyDisplay() {
+        return `${this._rawYaml.status?.containerStatuses?.filter(c => c.ready).length}/${this
+            ._rawYaml.spec?.containers.length}`;
+    }
+    get readyContainerCount() {
+        return this._rawYaml.status?.containerStatuses?.filter(c => c.ready).length;
+    }
+    get containerCount() {
+        return this._rawYaml.spec?.containers.length;
+    }
+    get stateDisplay() {
+        if (this.metadata.deletionTimestamp) {
+            return WorkloadState.TERMINATING;
+        }
+        return this.status?.phase?.toLowerCase() || WorkloadState.UNKNOWN;
+    }
+}

package/lib/src/models/resource-model.d.ts

@@ -2,11 +2,11 @@ import { GlobalStore, Unstructured } from 'k8s-api-provider';
 export type IResourceModel = Unstructured & ResourceModel;
 export declare class ResourceModel<T extends Unstructured = Unstructured> {
     _rawYaml: T;
-    _globalStore: GlobalStore;
     id: string;
     apiVersion: T['apiVersion'];
     kind: T['kind'];
     metadata: T['metadata'];
+    _globalStore: GlobalStore;
     constructor(_rawYaml: T, _globalStore: GlobalStore);
     init(): Promise<void>;
     get name(): string | undefined;

package/lib/src/models/resource-model.js

@@ -0,0 +1,34 @@
+export class ResourceModel {
+    _rawYaml;
+    _globalStore;
+    id;
+    apiVersion;
+    kind;
+    metadata;
+    constructor(_rawYaml, _globalStore) {
+        this._rawYaml = _rawYaml;
+        this._globalStore = _globalStore;
+        Object.keys(_rawYaml).forEach(key => {
+            Object.defineProperty(this, key, {
+                value: _rawYaml[key],
+            });
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    async init() { }
+    get name() {
+        return this._rawYaml.metadata?.name;
+    }
+    get namespace() {
+        return this._rawYaml.metadata?.namespace;
+    }
+    get labels() {
+        return this._rawYaml.metadata?.labels;
+    }
+    get annotations() {
+        return this._rawYaml.metadata?.annotations;
+    }
+    restore() {
+        return this._rawYaml;
+    }
+}

package/lib/src/models/server-instance-model.d.ts

@@ -0,0 +1,10 @@
+import { GlobalStore, Unstructured } from 'k8s-api-provider';
+import { ResourceModel } from './resource-model';
+type ServerInstanceTypes = Required<Unstructured>;
+export declare class ServerInstanceModel extends ResourceModel<ServerInstanceTypes> {
+    _rawYaml: ServerInstanceTypes;
+    _globalStore: GlobalStore;
+    sshMethod: 'password' | 'privateKey';
+    constructor(_rawYaml: ServerInstanceTypes, _globalStore: GlobalStore);
+}
+export {};

package/lib/src/models/service-model.d.ts

@@ -11,7 +11,6 @@ export declare enum ServiceTypeEnum {
 }
 export declare class ServiceModel extends ResourceModel<ServiceType> {
     _rawYaml: ServiceType;
-    _globalStore: GlobalStore;
     constructor(_rawYaml: ServiceType, _globalStore: GlobalStore);
     get displayType(): string | undefined;
     get dnsRecord(): string;

package/lib/src/models/service-model.js

@@ -0,0 +1,17 @@
+import { ResourceModel } from './resource-model';
+export class ServiceModel extends ResourceModel {
+    _rawYaml;
+    _globalStore;
+    constructor(_rawYaml, _globalStore) {
+        super(_rawYaml, _globalStore);
+        this._rawYaml = _rawYaml;
+        this._globalStore = _globalStore;
+    }
+    inClusterAccess() {
+        if (this._rawYaml.spec.type &&
+            ['ClusterIP', 'NodePort', 'LoadBalancer'].includes(this._rawYaml.spec.type)) {
+            return this._rawYaml.spec.clusterIP;
+        }
+        return this._rawYaml.spec.externalName;
+    }
+}

package/lib/src/models/statefulset-model.d.ts

@@ -5,7 +5,6 @@ import { WorkloadModel } from './workload-model';
 type RequiredStatefulSet = Required<StatefulSet> & Unstructured;
 export declare class StatefulSetModel extends WorkloadModel {
     _rawYaml: RequiredStatefulSet;
-    _globalStore: GlobalStore;
     spec?: RequiredStatefulSet['spec'];
     status?: RequiredStatefulSet['status'];
     constructor(_rawYaml: RequiredStatefulSet, _globalStore: GlobalStore);