@daocloud-proto/baize 0.101.3 → 0.102.0

package/common/k8s.pb.ts

@@ -7,6 +7,7 @@
 export enum KubeVolumeVolumeType {
   VOLUME_TYPE_UNSPECIFIED = "VOLUME_TYPE_UNSPECIFIED",
   PERSISTENT_VOLUME_CLAIM = "PERSISTENT_VOLUME_CLAIM",
+  DATASET = "DATASET",
 }
 
 export type Resources = {

package/management-api/cluster/v1alpha1/cluster.pb.ts

@@ -79,6 +79,26 @@ export type ResourceRange = {
   maxDesc?: string
 }
 
+export type StorageClass = {
+  cluster?: string
+  name?: string
+  isDefault?: boolean
+  provisioner?: string
+  allowReclaim?: boolean
+}
+
+export type ListStorageClassesRequest = {
+  workspace?: number
+  cluster?: string
+  namespace?: string
+  page?: BaizeCommonCommon.Pagination
+}
+
+export type ListStorageClassesResponse = {
+  items?: StorageClass[]
+  page?: BaizeCommonCommon.Pagination
+}
+
 export type GPUSettingsResponse = {
   items?: GPUSetting[]
 }
@@ -89,10 +109,10 @@ export type ClusterSettingsRequest = {
 
 export class ClusterService {
   static ListClusters(req: ListAIClustersRequest, initReq?: fm.InitReq): Promise<ListAIClustersResponse> {
-    return fm.fetchReq<ListAIClustersRequest, ListAIClustersResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<ListAIClustersRequest, ListAIClustersResponse>(`/apis/baize.io/v1alpha1/clusters?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
   }
   static ListClusterNamespaces(req: ListClusterNamespaceRequest, initReq?: fm.InitReq): Promise<ListClusterNamespaceResponse> {
-    return fm.fetchReq<ListClusterNamespaceRequest, ListClusterNamespaceResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces?${fm.renderURLSearchParams(req, ["workspace", "cluster"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<ListClusterNamespaceRequest, ListClusterNamespaceResponse>(`/apis/baize.io/v1alpha1/clusters/${req["cluster"]}/namespaces?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
   }
   static ListPVCs(req: ListPVCsRequest, initReq?: fm.InitReq): Promise<ListPVCsResponse> {
     return fm.fetchReq<ListPVCsRequest, ListPVCsResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/pvcs?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace"])}`, {...initReq, method: "GET"})
@@ -100,4 +120,7 @@ export class ClusterService {
   static GetClusterGPUSettings(req: ClusterSettingsRequest, initReq?: fm.InitReq): Promise<GPUSettingsResponse> {
     return fm.fetchReq<ClusterSettingsRequest, GPUSettingsResponse>(`/apis/baize.io/v1alpha1/clusters/${req["cluster"]}/settings/gpu-resources?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
   }
+  static ListStorageClasses(req: ListStorageClassesRequest, initReq?: fm.InitReq): Promise<ListStorageClassesResponse> {
+    return fm.fetchReq<ListStorageClassesRequest, ListStorageClassesResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/storage-classes?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace"])}`, {...initReq, method: "GET"})
+  }
 }

package/management-api/dataset/v1alpha1/dataset.pb.ts

@@ -0,0 +1,173 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as BaizeCommonCommon from "../../../common/common.pb"
+import * as fm from "../../../fetch.pb"
+
+type Absent<T, K extends keyof T> = { [k in Exclude<keyof T, K>]?: undefined };
+type OneOf<T> =
+  | { [k in keyof T]?: undefined }
+  | (
+    keyof T extends infer K ?
+      (K extends string & keyof T ? { [k in K]: T[K] } & Absent<T, K>
+        : never)
+    : never);
+
+export enum DataSourceType {
+  DATA_SOURCE_TYPE_UNSPECIFIED = "DATA_SOURCE_TYPE_UNSPECIFIED",
+  GIT = "GIT",
+  S3 = "S3",
+  HTTP = "HTTP",
+  PVC = "PVC",
+  NFS = "NFS",
+}
+
+export enum DatasetStatusPhase {
+  DATA_SET_PHASE_UNSPECIFIED = "DATA_SET_PHASE_UNSPECIFIED",
+  PENDING = "PENDING",
+  READY = "READY",
+  PROCESSING = "PROCESSING",
+  FAILED = "FAILED",
+}
+
+export enum SecretOptionsAuthType {
+  AUTH_TYPE_UNSPECIFIED = "AUTH_TYPE_UNSPECIFIED",
+  BASIC = "BASIC",
+  SSH = "SSH",
+  TOKEN = "TOKEN",
+  AK_SK = "AK_SK",
+}
+
+export enum DatasetBoundPVCAccessMode {
+  ACCESS_MODE_UNSPECIFIED = "ACCESS_MODE_UNSPECIFIED",
+  READ_ONLY_MANY = "READ_ONLY_MANY",
+  READ_WRITE_ONCE = "READ_WRITE_ONCE",
+  READ_WRITE_MANY = "READ_WRITE_MANY",
+}
+
+export type DataSource = {
+  type?: DataSourceType
+  uri?: string
+  options?: DataSourceOptions
+}
+
+export type DatasetStatus = {
+  phase?: DatasetStatusPhase
+}
+
+export type Dataset = {
+  name?: string
+  cluster?: string
+  namespace?: string
+  source?: DataSource
+  secretRef?: string
+  pvcName?: string
+  status?: DatasetStatus
+  description?: string
+}
+
+export type DataSourceOptionsGit = {
+  branch?: string
+  commit?: string
+  depth?: number
+  submodules?: boolean
+}
+
+export type DataSourceOptionsS3 = {
+  region?: string
+  endpoint?: string
+}
+
+export type DataSourceOptionsHttp = {
+  headers?: {[key: string]: string}
+}
+
+
+/* baize modified */ export type BaseDataSourceOptions = {
+}
+
+export type DataSourceOptions = BaseDataSourceOptions
+  & OneOf<{ git: DataSourceOptionsGit; s3: DataSourceOptionsS3; http: DataSourceOptionsHttp }>
+
+export type SecretOptionsBasicAuth = {
+  username?: string
+  password?: string
+}
+
+export type SecretOptionsSSHAuth = {
+  privateKey?: string
+  passphrase?: string
+}
+
+export type SecretOptionsTokenAuth = {
+  token?: string
+}
+
+export type SecretOptionsAkSkAuth = {
+  accessKey?: string
+  secretKey?: string
+}
+
+
+/* baize modified */ export type BaseSecretOptions = {
+  authType?: SecretOptionsAuthType
+}
+
+export type SecretOptions = BaseSecretOptions
+  & OneOf<{ basic: SecretOptionsBasicAuth; ssh: SecretOptionsSSHAuth; token: SecretOptionsTokenAuth; akSk: SecretOptionsAkSkAuth }>
+
+export type DatasetBoundPVC = {
+  storageClassName?: string
+  accessMode?: DatasetBoundPVCAccessMode
+  labels?: {[key: string]: string}
+  annotations?: {[key: string]: string}
+  capacity?: string
+}
+
+export type CreateDatasetRequest = {
+  workspace?: number
+  cluster?: string
+  namespace?: string
+  name?: string
+  source?: DataSource
+  secretOptions?: SecretOptions
+  boundPVC?: DatasetBoundPVC
+  description?: string
+}
+
+export type ListDatasetRequest = {
+  workspace?: number
+  cluster?: string
+  namespace?: string
+  page?: BaizeCommonCommon.Pagination
+}
+
+export type ListDatasetResponse = {
+  items?: Dataset[]
+  page?: BaizeCommonCommon.Pagination
+}
+
+export type SingleDatasetRequest = {
+  workspace?: number
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export class DatasetManagement {
+  static ListDatasets(req: ListDatasetRequest, initReq?: fm.InitReq): Promise<ListDatasetResponse> {
+    return fm.fetchReq<ListDatasetRequest, ListDatasetResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/datasets?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace"])}`, {...initReq, method: "GET"})
+  }
+  static GetDataset(req: SingleDatasetRequest, initReq?: fm.InitReq): Promise<Dataset> {
+    return fm.fetchReq<SingleDatasetRequest, Dataset>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/datasets/${req["name"]}?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
+  static CreateDataset(req: CreateDatasetRequest, initReq?: fm.InitReq): Promise<Dataset> {
+    return fm.fetchReq<CreateDatasetRequest, Dataset>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/datasets`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
+  static DeleteDataset(req: SingleDatasetRequest, initReq?: fm.InitReq): Promise<Dataset> {
+    return fm.fetchReq<SingleDatasetRequest, Dataset>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/datasets/${req["name"]}`, {...initReq, method: "DELETE"})
+  }
+}

package/management-api/job/v1alpha1/job.pb.ts

@@ -30,8 +30,10 @@ export enum JobActionRequestAction {
 }
 
 
-type BaseJob = {
+/* baize modified */ export type BaseJob = {
   type?: JobType
+  queueName?: string
+  runningDuration?: number
 }
 
 export type Job = BaseJob
@@ -59,13 +61,14 @@ export type SingleJobRequest = {
 }
 
 
-type BaseCreateJobRequest = {
+/* baize modified */ export type BaseCreateJobRequest = {
   workspace?: number
   type?: JobType
   cluster?: string
   namespace?: string
   name?: string
   description?: string
+  queueName?: string
 }
 
 export type CreateJobRequest = BaseCreateJobRequest
@@ -80,20 +83,40 @@ export type JobActionRequest = {
   action?: JobActionRequestAction
 }
 
+export type JobInstanceContainer = {
+  name?: string
+}
+
+export type JobInstance = {
+  cluster?: string
+  namespace?: string
+  name?: string
+  phase?: string
+  containers?: JobInstanceContainer[]
+}
+
+export type JobInstanceListResponse = {
+  items?: JobInstance[]
+  page?: BaizeCommonCommon.Pagination
+}
+
 export class JobsManagement {
   static ListJobs(req: ListJobsRequest, initReq?: fm.InitReq): Promise<ListJobsResponse> {
-    return fm.fetchReq<ListJobsRequest, ListJobsResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/jobs?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<ListJobsRequest, ListJobsResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/jobs?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
   }
   static GetJob(req: SingleJobRequest, initReq?: fm.InitReq): Promise<Job> {
     return fm.fetchReq<SingleJobRequest, Job>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/jobs/${req["name"]}?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }
+  static GetJobInstanceList(req: SingleJobRequest, initReq?: fm.InitReq): Promise<JobInstanceListResponse> {
+    return fm.fetchReq<SingleJobRequest, JobInstanceListResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/jobs/${req["name"]}/instances?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
   static CreateJob(req: CreateJobRequest, initReq?: fm.InitReq): Promise<Job> {
     return fm.fetchReq<CreateJobRequest, Job>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/jobs`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
   }
   static DeleteJob(req: SingleJobRequest, initReq?: fm.InitReq): Promise<Job> {
     return fm.fetchReq<SingleJobRequest, Job>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/jobs/${req["name"]}`, {...initReq, method: "DELETE", body: JSON.stringify(req, fm.replacer)})
   }
-  static DoJobAction(req: SingleJobRequest, initReq?: fm.InitReq): Promise<Job> {
-    return fm.fetchReq<SingleJobRequest, Job>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/jobs/${req["name"]}/actions`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  static DoJobAction(req: JobActionRequest, initReq?: fm.InitReq): Promise<Job> {
+    return fm.fetchReq<JobActionRequest, Job>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/jobs/${req["name"]}/actions`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
   }
 }

package/management-api/metrics/v1alpha1/metrics.pb.ts

@@ -4,7 +4,9 @@
 * This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
 */
 
+import * as BaizeCommonCommon from "../../../common/common.pb"
 import * as fm from "../../../fetch.pb"
+import * as BaizeManagement_apiJobV1alpha1Job from "../../job/v1alpha1/job.pb"
 
 export enum QueryMetric {
   QUERY_METRIC_UNSPECIFIED = "QUERY_METRIC_UNSPECIFIED",
@@ -21,6 +23,17 @@ export enum QueryMetric {
   QUERY_METRIC_TOTAL_CLUSTERS = "QUERY_METRIC_TOTAL_CLUSTERS",
 }
 
+export enum DevDashboardQueryMetric {
+  DEV_DASH_QUERY_METRIC_UNSPECIFIED = "DEV_DASH_QUERY_METRIC_UNSPECIFIED",
+  DEV_DASH_QUERY_RUNNING_NOTEBOOKS = "DEV_DASH_QUERY_RUNNING_NOTEBOOKS",
+  DEV_DASH_QUERY_TOTAL_NOTEBOOKS = "DEV_DASH_QUERY_TOTAL_NOTEBOOKS",
+  DEV_DASH_QUERY_RUNNING_PYTORCH_JOBS = "DEV_DASH_QUERY_RUNNING_PYTORCH_JOBS",
+  DEV_DASH_QUERY_TOTAL_PYTORCH_JOBS = "DEV_DASH_QUERY_TOTAL_PYTORCH_JOBS",
+  DEV_DASH_QUERY_RUNNING_TENSORFLOW_JOBS = "DEV_DASH_QUERY_RUNNING_TENSORFLOW_JOBS",
+  DEV_DASH_QUERY_TOTAL_TENSORFLOW_JOBS = "DEV_DASH_QUERY_TOTAL_TENSORFLOW_JOBS",
+  DEV_DASH_QUERY_TOTAL_DATASETS = "DEV_DASH_QUERY_TOTAL_DATASETS",
+}
+
 export enum QueryTimeSeriesMetric {
   QUERY_TIME_SERIES_UNSPECIFIED = "QUERY_TIME_SERIES_UNSPECIFIED",
   QUERY_TIME_SERIES_METRIC_GPU_DISTRIBUTION = "QUERY_TIME_SERIES_METRIC_GPU_DISTRIBUTION",
@@ -40,6 +53,12 @@ export enum VectorQueryResponseStatus {
   FAILURE = "FAILURE",
 }
 
+export enum DevDashboardVectorQueryResponseStatus {
+  STATUS_UNSPECIFIED = "STATUS_UNSPECIFIED",
+  SUCCESS = "SUCCESS",
+  FAILURE = "FAILURE",
+}
+
 export enum TimeSeriesVectorQueryResponseStatus {
   STATUS_UNSPECIFIED = "STATUS_UNSPECIFIED",
   SUCCESS = "SUCCESS",
@@ -76,6 +95,13 @@ export type VectorQueryResponse = {
   metric?: QueryMetric
 }
 
+export type DevDashboardVectorQueryResponse = {
+  vector?: Vector
+  error?: string
+  status?: DevDashboardVectorQueryResponseStatus
+  metric?: DevDashboardQueryMetric
+}
+
 export type TimeSeriesVectorQueryResponse = {
   matrix?: Matrix
   error?: string
@@ -83,16 +109,46 @@ export type TimeSeriesVectorQueryResponse = {
   metric?: QueryTimeSeriesMetric
 }
 
+export type TaskStatsBoard = {
+  cluster?: string
+  namespace?: string
+  type?: BaizeManagement_apiJobV1alpha1Job.JobType
+  running?: number
+  pending?: number
+  failed?: number
+  total?: number
+}
+
+export type TaskStatsBoardRequest = {
+  workspace?: number
+  page?: BaizeCommonCommon.Pagination
+}
+
+export type TaskStatsBoardResponse = {
+  items?: TaskStatsBoard[]
+  page?: BaizeCommonCommon.Pagination
+}
+
 export type QueryMultipleVectorRequest = {
   queryMetrics?: QueryMetric[]
   time?: string
   cluster?: string
 }
 
+export type QueryDevDashboardMultipleVectorRequest = {
+  queryMetrics?: DevDashboardQueryMetric[]
+  time?: string
+  workspace?: number
+}
+
 export type MultipleVectorQueryResponse = {
   items?: VectorQueryResponse[]
 }
 
+export type MultipleDevDashboardVectorQueryResponse = {
+  items?: VectorQueryResponse[]
+}
+
 export type QueryTimeSeriesVectorsRequest = {
   queryMetrics?: QueryTimeSeriesMetric[]
   queryMetricRange?: QueryTimeSeriesMetricRange
@@ -110,4 +166,10 @@ export class MetricsService {
   static QueryTimeSeriesVectors(req: QueryTimeSeriesVectorsRequest, initReq?: fm.InitReq): Promise<QueryTimeSeriesVectorsResponse> {
     return fm.fetchReq<QueryTimeSeriesVectorsRequest, QueryTimeSeriesVectorsResponse>(`/apis/baize.io/v1alpha1/metrics/time-series-queries?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
   }
+  static QueryDevDashboardMultipleVectors(req: QueryDevDashboardMultipleVectorRequest, initReq?: fm.InitReq): Promise<DevDashboardVectorQueryResponse> {
+    return fm.fetchReq<QueryDevDashboardMultipleVectorRequest, DevDashboardVectorQueryResponse>(`/apis/baize.io/v1alpha1/metrics/dev-dashboard-multiple-queries?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+  static QueryDevDashboardTaskStats(req: TaskStatsBoardRequest, initReq?: fm.InitReq): Promise<TaskStatsBoardResponse> {
+    return fm.fetchReq<TaskStatsBoardRequest, TaskStatsBoardResponse>(`/apis/baize.io/v1alpha1/metrics/dev-dashboard-task-stats?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
 }

package/management-api/notebook/v1alpha1/notebook.pb.ts

@@ -43,6 +43,7 @@ export type ListNotebooksRequest = {
   workspace?: number
   cluster?: string
   namespace?: string
+  queueName?: string
   page?: BaizeCommonCommon.Pagination
 }
 
@@ -84,6 +85,7 @@ export type Notebook = {
   cluster?: string
   namespace?: string
   name?: string
+  queueName?: string
   type?: NotebookType
   config?: NotebookConfig
   creationTimestamp?: GoogleProtobufTimestamp.Timestamp
@@ -107,10 +109,19 @@ export type CreateNotebookRequest = {
   cluster?: string
   namespace?: string
   name?: string
+  queueName?: string
   type?: NotebookType
   config?: NotebookConfig
 }
 
+export type UpdateNotebookRequest = {
+  workspace?: number
+  cluster?: string
+  namespace?: string
+  name?: string
+  config?: NotebookConfig
+}
+
 export type NotebookActionRequest = {
   workspace?: number
   cluster?: string
@@ -134,7 +145,7 @@ export type NotebookImageListResponse = {
 
 export class NotebookService {
   static ListNotebooks(req: ListNotebooksRequest, initReq?: fm.InitReq): Promise<ListNotebooksResponse> {
-    return fm.fetchReq<ListNotebooksRequest, ListNotebooksResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/notebooks?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<ListNotebooksRequest, ListNotebooksResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/notebooks?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
   }
   static GetNotebook(req: SingleNotebookRequest, initReq?: fm.InitReq): Promise<Notebook> {
     return fm.fetchReq<SingleNotebookRequest, Notebook>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/notebooks/${req["name"]}?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
@@ -142,6 +153,9 @@ export class NotebookService {
   static CreateNotebook(req: CreateNotebookRequest, initReq?: fm.InitReq): Promise<Notebook> {
     return fm.fetchReq<CreateNotebookRequest, Notebook>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/notebooks`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
   }
+  static UpdateNotebook(req: UpdateNotebookRequest, initReq?: fm.InitReq): Promise<Notebook> {
+    return fm.fetchReq<UpdateNotebookRequest, Notebook>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/notebooks/${req["name"]}`, {...initReq, method: "PUT", body: JSON.stringify(req, fm.replacer)})
+  }
   static NotebookDoAction(req: NotebookActionRequest, initReq?: fm.InitReq): Promise<Notebook> {
     return fm.fetchReq<NotebookActionRequest, Notebook>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/notebooks/${req["name"]}/actions`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
   }

package/management-api/queue/v1alpha1/queue.pb.ts

@@ -17,6 +17,12 @@ export enum QueuePhase {
   READY = "READY",
 }
 
+export enum QueueStrategy {
+  QUEUE_STRATEGY_UNSPECIFIED = "QUEUE_STRATEGY_UNSPECIFIED",
+  STRICT_FIFO = "STRICT_FIFO",
+  BEST_EFFORT_FIFO = "BEST_EFFORT_FIFO",
+}
+
 export type QueueResource = {
   name?: string
   value?: string
@@ -34,7 +40,9 @@ export type Queue = {
   workspace?: number
   description?: string
   resources?: QueueResource[]
+  resourcesAvailable?: QueueResource[]
   status?: QueueStatus
+  strategy?: QueueStrategy
 }
 
 export type ListQueueRequest = {
@@ -55,6 +63,7 @@ export type CreateQueueRequest = {
   workspace?: number
   description?: string
   resources?: QueueResource[]
+  strategy?: QueueStrategy
 }
 
 export type DeleteQueueRequest = {
@@ -63,6 +72,36 @@ export type DeleteQueueRequest = {
   name?: string
 }
 
+export type CheckQueueRequest = {
+  type?: QueueType
+  workspace?: string
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type CheckQueueResponse = {
+  type?: QueueType
+  exist?: boolean
+}
+
+export type CreateLocalQueueRequest = {
+  type?: QueueType
+  workspace?: string
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type CreateLocalQueueResponse = {
+  type?: QueueType
+  workspace?: string
+  cluster?: string
+  namespace?: string
+  name?: string
+  status?: QueueStatus
+}
+
 export class QueueManagement {
   static ListQueues(req: ListQueueRequest, initReq?: fm.InitReq): Promise<ListQueueResponse> {
     return fm.fetchReq<ListQueueRequest, ListQueueResponse>(`/apis/baize.io/v1alpha1/clusters/${req["cluster"]}/queues?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
@@ -73,4 +112,10 @@ export class QueueManagement {
   static DeleteQueue(req: DeleteQueueRequest, initReq?: fm.InitReq): Promise<Queue> {
     return fm.fetchReq<DeleteQueueRequest, Queue>(`/apis/baize.io/v1alpha1/clusters/${req["cluster"]}/queues/${req["name"]}`, {...initReq, method: "DELETE", body: JSON.stringify(req, fm.replacer)})
   }
+  static CheckQueue(req: CheckQueueRequest, initReq?: fm.InitReq): Promise<CheckQueueResponse> {
+    return fm.fetchReq<CheckQueueRequest, CheckQueueResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/queues/${req["name"]}/capacites?${fm.renderURLSearchParams(req, ["workspace", "cluster", "name"])}`, {...initReq, method: "GET"})
+  }
+  static CreateLocalQueue(req: CreateLocalQueueRequest, initReq?: fm.InitReq): Promise<CreateLocalQueueResponse> {
+    return fm.fetchReq<CreateLocalQueueRequest, CreateLocalQueueResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/localqueues`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daocloud-proto/baize",
-  "version": "v0.101.3",
+  "version": "v0.102.0",
   "description": "",
   "author": "",
   "license": "ISC"