@daocloud-proto/mcamel-rocketmq 0.0.1

package/cloudshell.pb.ts

@@ -0,0 +1,78 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as GoogleProtobufEmpty from "../../../google/protobuf/empty.pb"
+import * as CommonCommon from "./common.pb"
+import * as fm from "./fetch.pb"
+
+export enum CreateCloudShellRequestType {
+  TYPE_UNSPECIFIED = "TYPE_UNSPECIFIED",
+  bash = "bash",
+  exec = "exec",
+  logs = "logs",
+  upload = "upload",
+  download = "download",
+}
+
+export type ObjectMeta = {
+  name?: string
+  namespace?: string
+  uid?: string
+  resourceVersion?: string
+  creationTimestamp?: string
+  deletionTimestamp?: string
+  labels?: {[key: string]: string}
+  annotations?: {[key: string]: string}
+  ownerReferences?: CommonCommon.OwnerReference[]
+  cluster?: string
+  workspaceAlias?: string
+}
+
+export type CloudShell = {
+  metadata?: ObjectMeta
+  spec?: CloudShellSpec
+  status?: CloudShellStatus
+}
+
+export type CloudShellSpec = {
+  configMapName?: string
+  once?: boolean
+  commandAction?: string
+  ttl?: number
+  cleanup?: boolean
+}
+
+export type CloudShellStatus = {
+  phase?: string
+  accessUrl?: string
+}
+
+export type CreateCloudShellRequest = {
+  type?: CreateCloudShellRequestType
+  cluster?: string
+  namespace?: string
+  podName?: string
+  filePath?: string
+  container?: string
+  logCount?: number
+  data?: CloudShell
+}
+
+export type GetorDeleteCloudShellRequest = {
+  name?: string
+}
+
+export class CloudShellService {
+  static CreateCloudShell(req: CreateCloudShellRequest, initReq?: fm.InitReq): Promise<CloudShell> {
+    return fm.fetchReq<CreateCloudShellRequest, CloudShell>(`/apis/mcamel.io/rocketmq/v1alpha1/cloudshells`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+  static GetCloudShell(req: GetorDeleteCloudShellRequest, initReq?: fm.InitReq): Promise<CloudShell> {
+    return fm.fetchReq<GetorDeleteCloudShellRequest, CloudShell>(`/apis/mcamel.io/rocketmq/v1alpha1/cloudshells/${req["name"]}?${fm.renderURLSearchParams(req, ["name"])}`, {...initReq, method: "GET"})
+  }
+  static DeleteCloudShell(req: GetorDeleteCloudShellRequest, initReq?: fm.InitReq): Promise<GoogleProtobufEmpty.Empty> {
+    return fm.fetchReq<GetorDeleteCloudShellRequest, GoogleProtobufEmpty.Empty>(`/apis/mcamel.io/rocketmq/v1alpha1/cloudshells/${req["name"]}`, {...initReq, method: "DELETE"})
+  }
+}

package/cluster.pb.ts

@@ -0,0 +1,323 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as CommonCommon from "./common.pb"
+import * as fm from "./fetch.pb"
+
+export enum PermissionsType {
+  None = "None",
+  GetInstance = "GetInstance",
+  CreateInstance = "CreateInstance",
+  UpdateInstance = "UpdateInstance",
+  DeleteInstance = "DeleteInstance",
+  GetMetric = "GetMetric",
+  GetInstanceLog = "GetInstanceLog",
+  GetConfig = "GetConfig",
+  UpdateConfig = "UpdateConfig",
+  GetBackup = "GetBackup",
+  CreateBackup = "CreateBackup",
+  UpdateBackup = "UpdateBackup",
+  DeleteBackup = "DeleteBackup",
+  GetBackupConf = "GetBackupConf",
+  CreateBackupConf = "CreateBackupConf",
+  UpdateBackupConf = "UpdateBackupConf",
+  DeleteBackupConf = "DeleteBackupConf",
+}
+
+export enum EventType {
+  EVENT_TYPE_UNSPECIFIED = "EVENT_TYPE_UNSPECIFIED",
+  Normal = "Normal",
+  Warning = "Warning",
+}
+
+export enum GetAllEventListReqSortDir {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+
+export enum GetEventListReqKind {
+  KIND_UNSPECIFIED = "KIND_UNSPECIFIED",
+  Pod = "Pod",
+}
+
+export enum GetWorkspaceListReqSortDir {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+
+export enum GetInsightAgentStatusRespInsightAgentStatus {
+  NotInstall = "NotInstall",
+  Install = "Install",
+}
+
+export type GetPermissionsListReq = {
+  workspaceId?: number
+}
+
+export type GetPermissionsListRespPermissions = {
+  getInstance?: boolean
+  createInstance?: boolean
+  updateInstance?: boolean
+  deleteInstance?: boolean
+  getMetric?: boolean
+  getInstanceLog?: boolean
+  getConfig?: boolean
+  updateConfig?: boolean
+  getBackup?: boolean
+  createBackup?: boolean
+  updateBackup?: boolean
+  deleteBackup?: boolean
+  getBackupConf?: boolean
+  createBackupConf?: boolean
+  updateBackupConf?: boolean
+  deleteBackupConf?: boolean
+}
+
+export type GetPermissionsListResp = {
+  permissionsBool?: GetPermissionsListRespPermissions
+  permissions?: PermissionsType[]
+}
+
+export type GetAllEventKindsListResp = {
+  data?: string[]
+}
+
+export type GetAllEventKindsListReq = {
+  cluster?: string
+}
+
+export type GetAllEventListReq = {
+  page?: number
+  pageSize?: number
+  sortDir?: GetAllEventListReqSortDir
+  sortBy?: string
+  searchKey?: string
+  cluster?: string
+  namespace?: string
+  name?: string
+  eventType?: EventType
+  kindName?: string
+}
+
+export type GetAllEventListRespItemsSource = {
+  component?: string
+}
+
+export type GetAllEventListRespItemsMetadata = {
+  uid?: string
+  name?: string
+  namespace?: string
+  annotations?: {[key: string]: string}
+  resourceVersion?: string
+  creationTimestamp?: string
+}
+
+export type GetAllEventListRespItemsInvolvedObject = {
+  uid?: string
+  kind?: string
+  name?: string
+  namespace?: string
+  apiVersion?: string
+  resourceVersion?: string
+}
+
+export type GetAllEventListRespItems = {
+  kind?: string
+  type?: string
+  count?: number
+  reason?: string
+  source?: GetAllEventListRespItemsSource
+  message?: string
+  metadata?: GetAllEventListRespItemsMetadata
+  apiVersion?: string
+  lastTimestamp?: string
+  firstTimestamp?: string
+  involvedObject?: GetAllEventListRespItemsInvolvedObject
+  reportingInstance?: string
+  reportingComponent?: string
+}
+
+export type GetAllEventListResp = {
+  items?: GetAllEventListRespItems[]
+  pagination?: CommonCommon.Pagination
+}
+
+export type GetClusterNodeLabelListReq = {
+  cluster?: string
+}
+
+export type GetClusterNodeLabelListRespLabel = {
+  key?: string
+  value?: string[]
+}
+
+export type GetClusterNodeLabelListResp = {
+  items?: GetClusterNodeLabelListRespLabel[]
+  pagination?: CommonCommon.Pagination
+}
+
+export type GetClusterPodLabelListReq = {
+  page?: number
+  pageSize?: number
+  searchKey?: string
+  filterNamespace?: string
+  cluster?: string
+}
+
+export type GetClusterPodLabelListRespLabel = {
+  key?: string
+  value?: string[]
+}
+
+export type GetClusterPodLabelListResp = {
+  items?: GetClusterPodLabelListRespLabel[]
+  pagination?: CommonCommon.Pagination
+}
+
+export type GetClusterNodePortListReq = {
+  cluster?: string
+}
+
+export type GetClusterNodePortListResp = {
+  items?: string[]
+  pagination?: CommonCommon.Pagination
+}
+
+export type EventSource = {
+  component?: string
+  host?: string
+}
+
+export type GetMetallbIPAddressPoolsListReq = {
+  cluster?: string
+}
+
+export type GetMetallbIPAddressPoolsListRespItem = {
+  name?: string
+  addresses?: string[]
+  autoAssign?: boolean
+  avoidBuggyIPs?: boolean
+}
+
+export type GetMetallbIPAddressPoolsListResp = {
+  items?: GetMetallbIPAddressPoolsListRespItem[]
+  isSupportLb?: boolean
+  externalTrafficPolicy?: CommonCommon.ExternalTrafficPolicy[]
+  lbTyp?: CommonCommon.LBTyp[]
+}
+
+export type GetEventListReq = {
+  cluster?: string
+  namespace?: string
+  kind?: GetEventListReqKind
+  kindName?: string
+  page?: number
+  pageSize?: number
+  type?: EventType[]
+}
+
+export type ObjectReference = {
+  kind?: string
+  name?: string
+}
+
+export type GetEventListRespItem = {
+  involvedObject?: ObjectReference
+  reason?: string
+  message?: string
+  source?: EventSource
+  lastTimestamp?: string
+  type?: EventType
+}
+
+export type GetEventListResp = {
+  items?: GetEventListRespItem[]
+  pagination?: CommonCommon.Pagination
+}
+
+export type GetWorkspaceListReq = {
+  page?: number
+  pageSize?: number
+  sortDir?: GetWorkspaceListReqSortDir
+  sortBy?: string
+  searchKey?: string
+}
+
+export type GetWorkspaceListRespItem = {
+  workspaceId?: number
+  alias?: string
+}
+
+export type GetWorkspaceListResp = {
+  items?: GetWorkspaceListRespItem[]
+  pagination?: CommonCommon.Pagination
+}
+
+export type GetClusterListReq = {
+  workspaceId?: number
+}
+
+export type GetClusterListResp = {
+  items?: string[]
+  pagination?: CommonCommon.Pagination
+}
+
+export type GetClusterNamespaceListReq = {
+  workspaceId?: number
+  cluster?: string
+}
+
+export type GetClusterNamespaceListResp = {
+  items?: string[]
+  pagination?: CommonCommon.Pagination
+}
+
+export type GetInsightAgentStatusReq = {
+  cluster?: string
+}
+
+export type GetInsightAgentStatusResp = {
+  status?: GetInsightAgentStatusRespInsightAgentStatus
+}
+
+export class Cluster {
+  static GetClusterList(req: GetClusterListReq, initReq?: fm.InitReq): Promise<GetClusterListResp> {
+    return fm.fetchReq<GetClusterListReq, GetClusterListResp>(`/apis/mcamel.io/rocketmq/v1alpha1/${req["workspaceId"]}/clusters?${fm.renderURLSearchParams(req, ["workspaceId"])}`, {...initReq, method: "GET"})
+  }
+  static GetClusterNamespaceList(req: GetClusterNamespaceListReq, initReq?: fm.InitReq): Promise<GetClusterNamespaceListResp> {
+    return fm.fetchReq<GetClusterNamespaceListReq, GetClusterNamespaceListResp>(`/apis/mcamel.io/rocketmq/v1alpha1/${req["workspaceId"]}/${req["cluster"]}/namespaces?${fm.renderURLSearchParams(req, ["workspaceId", "cluster"])}`, {...initReq, method: "GET"})
+  }
+  static GetClusterNodePortList(req: GetClusterNodePortListReq, initReq?: fm.InitReq): Promise<GetClusterNodePortListResp> {
+    return fm.fetchReq<GetClusterNodePortListReq, GetClusterNodePortListResp>(`/apis/mcamel.io/rocketmq/v1alpha1/${req["cluster"]}/nodeports?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+  }
+  static GetClusterNodeLabelList(req: GetClusterNodeLabelListReq, initReq?: fm.InitReq): Promise<GetClusterNodeLabelListResp> {
+    return fm.fetchReq<GetClusterNodeLabelListReq, GetClusterNodeLabelListResp>(`/apis/mcamel.io/rocketmq/v1alpha1/${req["cluster"]}/nodelabels?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+  }
+  static GetClusterPodLabelList(req: GetClusterPodLabelListReq, initReq?: fm.InitReq): Promise<GetClusterPodLabelListResp> {
+    return fm.fetchReq<GetClusterPodLabelListReq, GetClusterPodLabelListResp>(`/apis/mcamel.io/rocketmq/v1alpha1/${req["cluster"]}/podlabels?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+  }
+  static GetWorkspaceList(req: GetWorkspaceListReq, initReq?: fm.InitReq): Promise<GetWorkspaceListResp> {
+    return fm.fetchReq<GetWorkspaceListReq, GetWorkspaceListResp>(`/apis/mcamel.io/rocketmq/v1alpha1/workspaces?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+  static GetInsightAgentStatus(req: GetInsightAgentStatusReq, initReq?: fm.InitReq): Promise<GetInsightAgentStatusResp> {
+    return fm.fetchReq<GetInsightAgentStatusReq, GetInsightAgentStatusResp>(`/apis/mcamel.io/rocketmq/v1alpha1/${req["cluster"]}/insight/status?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+  }
+  static GetEventList(req: GetEventListReq, initReq?: fm.InitReq): Promise<GetEventListResp> {
+    return fm.fetchReq<GetEventListReq, GetEventListResp>(`/apis/mcamel.io/rocketmq/v1alpha1/${req["cluster"]}/${req["namespace"]}/events?${fm.renderURLSearchParams(req, ["cluster", "namespace"])}`, {...initReq, method: "GET"})
+  }
+  static GetAllEventList(req: GetAllEventListReq, initReq?: fm.InitReq): Promise<GetAllEventListResp> {
+    return fm.fetchReq<GetAllEventListReq, GetAllEventListResp>(`/apis/mcamel.io/rocketmq/v1alpha1/${req["cluster"]}/${req["namespace"]}/${req["name"]}/all-events?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
+  static GetAllEventKindsList(req: GetAllEventKindsListReq, initReq?: fm.InitReq): Promise<GetAllEventKindsListResp> {
+    return fm.fetchReq<GetAllEventKindsListReq, GetAllEventKindsListResp>(`/apis/mcamel.io/rocketmq/v1alpha1/${req["cluster"]}/all-events-kinds?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+  }
+  static GetMetallbIPAddressPoolsList(req: GetMetallbIPAddressPoolsListReq, initReq?: fm.InitReq): Promise<GetMetallbIPAddressPoolsListResp> {
+    return fm.fetchReq<GetMetallbIPAddressPoolsListReq, GetMetallbIPAddressPoolsListResp>(`/apis/mcamel.io/rocketmq/v1alpha1/${req["cluster"]}/lbaddress/pools?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+  }
+  static GetPermissionsList(req: GetPermissionsListReq, initReq?: fm.InitReq): Promise<GetPermissionsListResp> {
+    return fm.fetchReq<GetPermissionsListReq, GetPermissionsListResp>(`/apis/mcamel.io/rocketmq/v1alpha1/${req["workspaceId"]}/permissions?${fm.renderURLSearchParams(req, ["workspaceId"])}`, {...initReq, method: "GET"})
+  }
+}

package/common.pb.ts

@@ -0,0 +1,214 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+export enum ExternalTrafficPolicy {
+  Cluster = "Cluster",
+  Local = "Local",
+}
+
+export enum LBTyp {
+  MetalLB = "MetalLB",
+  Others = "Others",
+}
+
+export enum ServiceType {
+  ClusterIP = "ClusterIP",
+  NodePort = "NodePort",
+  LoadBalancer = "LoadBalancer",
+}
+
+export enum PageInfoReqSortDir {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+
+export enum PodCommonPodPhase {
+  PHASE_UNSPECIFIED = "PHASE_UNSPECIFIED",
+  Unknown = "Unknown",
+  Pending = "Pending",
+  Running = "Running",
+  Succeeded = "Succeeded",
+  Failed = "Failed",
+}
+
+export enum PodCommonConditionStatus {
+  PodConditionStatusUnknown = "PodConditionStatusUnknown",
+  PodConditionStatusTrue = "PodConditionStatusTrue",
+  PodConditionStatusFalse = "PodConditionStatusFalse",
+}
+
+export type Affinity = {
+  nodeAffinity?: NodeAffinity
+  podAffinity?: PodAffinity
+  podAntiAffinity?: PodAntiAffinity
+}
+
+export type PodAntiAffinity = {
+  requiredDuringSchedulingIgnoredDuringExecution?: PodAffinityTerm[]
+  preferredDuringSchedulingIgnoredDuringExecution?: WeightedPodAffinityTerm[]
+}
+
+export type NodeAffinity = {
+  requiredDuringSchedulingIgnoredDuringExecution?: NodeSelector
+  preferredDuringSchedulingIgnoredDuringExecution?: PreferredSchedulingTerm[]
+}
+
+export type NodeSelector = {
+  nodeSelectorTerms?: NodeSelectorTerm[]
+}
+
+export type NodeSelectorTerm = {
+  matchExpressions?: NodeSelectorRequirement[]
+  matchFields?: NodeSelectorRequirement[]
+}
+
+export type NodeSelectorRequirement = {
+  key?: string
+  values?: string[]
+  operator?: string
+}
+
+export type PreferredSchedulingTerm = {
+  weight?: number
+  preference?: NodeSelectorTerm
+}
+
+export type PodAffinity = {
+  requiredDuringSchedulingIgnoredDuringExecution?: PodAffinityTerm[]
+  preferredDuringSchedulingIgnoredDuringExecution?: WeightedPodAffinityTerm[]
+}
+
+export type WeightedPodAffinityTerm = {
+  weight?: number
+  podAffinityTerm?: PodAffinityTerm
+}
+
+export type PodAffinityTerm = {
+  labelSelector?: LabelSelector
+  namespaces?: string[]
+  topologyKey?: string
+  namespaceSelector?: LabelSelector
+}
+
+export type LabelSelector = {
+  matchLabels?: {[key: string]: string}
+  matchExpressions?: LabelSelectorRequirement[]
+}
+
+export type LabelSelectorRequirement = {
+  key?: string
+  values?: string[]
+  operator?: string
+}
+
+export type Toleration = {
+  key?: string
+  operator?: string
+  value?: string
+  effect?: string
+  tolerationSeconds?: string
+}
+
+export type Pagination = {
+  total?: number
+  page?: number
+  pageSize?: number
+  pages?: number
+}
+
+export type PageInfoReq = {
+  page?: number
+  pageSize?: number
+  sortDir?: PageInfoReqSortDir
+  sortBy?: string
+}
+
+export type PodCommonCondition = {
+  lastTransitionTime?: string
+  lastUpdateTime?: string
+  message?: string
+  reason?: string
+  status?: PodCommonConditionStatus
+  type?: string
+}
+
+export type PodCommon = {
+  name?: string
+  phase?: PodCommonPodPhase
+  ip?: string
+  restartCount?: number
+  createTimestamp?: string
+  cpuUsage?: number
+  cpuLimit?: number
+  memoryUsage?: number
+  memoryLimit?: number
+  pvUsedInGb?: number
+  pvAllocatedInGb?: number
+  conditions?: PodCommonCondition[]
+  containersName?: string[]
+  ownerReference?: OwnerReference[]
+  initContainersName?: string[]
+  initContainersStatuses?: ContainerStatus[]
+}
+
+export type OwnerReference = {
+  uid?: string
+  controller?: boolean
+  name?: string
+  kind?: string
+}
+
+export type CommonItemStatus = {
+  serviceAddresses?: string[]
+  webManagerAddress?: string
+  webLogAddress?: string
+  avgPvAllocatedInGb?: number
+  avgPvUsedInGb?: number
+}
+
+export type AccessWhitelistInternal = {
+  namespace?: string
+  podSelector?: {[key: string]: string}
+}
+
+export type AccessWhitelistExternal = {
+  cidr?: string
+  ip?: string
+}
+
+export type AccessWhitelist = {
+  internals?: AccessWhitelistInternal[]
+  externals?: AccessWhitelistExternal[]
+}
+
+export type ContainerStatus = {
+  name?: string
+  state?: ContainerState
+}
+
+export type ContainerState = {
+  waiting?: ContainerStateWaiting
+  running?: ContainerStateRunning
+  terminated?: ContainerStateTerminated
+}
+
+export type ContainerStateWaiting = {
+  reason?: string
+  message?: string
+}
+
+export type ContainerStateRunning = {
+  startedAt?: string
+}
+
+export type ContainerStateTerminated = {
+  exitCode?: number
+  signal?: number
+  reason?: string
+  message?: string
+  startedAt?: string
+  finishedAt?: string
+}

package/fetch.pb.ts

@@ -0,0 +1,232 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+export interface InitReq extends RequestInit {
+  pathPrefix?: string
+}
+
+export function fetchReq<I, O>(path: string, init?: InitReq): Promise<O> {
+  const {pathPrefix, ...req} = init || {}
+
+  const url = pathPrefix ? `${pathPrefix}${path}` : path
+
+  return fetch(url, req).then(r => r.json().then((body: O) => {
+    if (!r.ok) { throw body; }
+    return body;
+  })) as Promise<O>
+}
+
+// NotifyStreamEntityArrival is a callback that will be called on streaming entity arrival
+export type NotifyStreamEntityArrival<T> = (resp: T) => void
+
+/**
+ * fetchStreamingRequest is able to handle grpc-gateway server side streaming call
+ * it takes NotifyStreamEntityArrival that lets users respond to entity arrival during the call
+ * all entities will be returned as an array after the call finishes.
+ **/
+export async function fetchStreamingRequest<S, R>(path: string, callback?: NotifyStreamEntityArrival<R>, init?: InitReq) {
+  const {pathPrefix, ...req} = init || {}
+  const url = pathPrefix ?`${pathPrefix}${path}` : path
+  const result = await fetch(url, req)
+  // needs to use the .ok to check the status of HTTP status code
+  // http other than 200 will not throw an error, instead the .ok will become false.
+  // see https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#
+  if (!result.ok) {
+    const resp = await result.json()
+    const errMsg = resp.error && resp.error.message ? resp.error.message : ""
+    throw new Error(errMsg)
+  }
+
+  if (!result.body) {
+    throw new Error("response doesnt have a body")
+  }
+
+  await result.body
+    .pipeThrough(new TextDecoderStream())
+    .pipeThrough<R>(getNewLineDelimitedJSONDecodingStream<R>())
+    .pipeTo(getNotifyEntityArrivalSink((e: R) => {
+      if (callback) {
+        callback(e)
+      }
+    }))
+
+  // wait for the streaming to finish and return the success respond
+  return
+}
+
+/**
+ * JSONStringStreamController represents the transform controller that's able to transform the incoming
+ * new line delimited json content stream into entities and able to push the entity to the down stream
+ */
+interface JSONStringStreamController<T> extends TransformStreamDefaultController {
+  buf?: string
+  pos?: number
+  enqueue: (s: T) => void
+}
+
+/**
+ * getNewLineDelimitedJSONDecodingStream returns a TransformStream that's able to handle new line delimited json stream content into parsed entities
+ */
+function getNewLineDelimitedJSONDecodingStream<T>(): TransformStream<string, T> {
+  return new TransformStream({
+    start(controller: JSONStringStreamController<T>) {
+      controller.buf = ''
+      controller.pos = 0
+    },
+
+    transform(chunk: string, controller: JSONStringStreamController<T>) {
+      if (controller.buf === undefined) {
+        controller.buf = ''
+      }
+      if (controller.pos === undefined) {
+        controller.pos = 0
+      }
+      controller.buf += chunk
+      while (controller.pos < controller.buf.length) {
+        if (controller.buf[controller.pos] === '\n') {
+          const line = controller.buf.substring(0, controller.pos)
+          const response = JSON.parse(line)
+          controller.enqueue(response.result)
+          controller.buf = controller.buf.substring(controller.pos + 1)
+          controller.pos = 0
+        } else {
+          ++controller.pos
+        }
+      }
+    }
+  })
+
+}
+
+/**
+ * getNotifyEntityArrivalSink takes the NotifyStreamEntityArrival callback and return
+ * a sink that will call the callback on entity arrival
+ * @param notifyCallback
+ */
+function getNotifyEntityArrivalSink<T>(notifyCallback: NotifyStreamEntityArrival<T>) {
+  return new WritableStream<T>({
+    write(entity: T) {
+      notifyCallback(entity)
+    }
+  })
+}
+
+type Primitive = string | boolean | number;
+type RequestPayload = Record<string, unknown>;
+type FlattenedRequestPayload = Record<string, Primitive | Array<Primitive>>;
+
+/**
+ * Checks if given value is a plain object
+ * Logic copied and adapted from below source: 
+ * https://github.com/char0n/ramda-adjunct/blob/master/src/isPlainObj.js
+ * @param  {unknown} value
+ * @return {boolean}
+ */
+function isPlainObject(value: unknown): boolean {
+  const isObject =
+    Object.prototype.toString.call(value).slice(8, -1) === "Object";
+  const isObjLike = value !== null && isObject;
+
+  if (!isObjLike || !isObject) {
+    return false;
+  }
+
+  const proto = Object.getPrototypeOf(value);
+
+  const hasObjectConstructor =
+    typeof proto === "object" &&
+    proto.constructor === Object.prototype.constructor;
+
+  return hasObjectConstructor;
+}
+
+/**
+ * Checks if given value is of a primitive type
+ * @param  {unknown} value
+ * @return {boolean}
+ */
+function isPrimitive(value: unknown): boolean {
+  return ["string", "number", "boolean"].some(t => typeof value === t);
+}
+
+/**
+ * Checks if given primitive is zero-value
+ * @param  {Primitive} value
+ * @return {boolean}
+ */
+function isZeroValuePrimitive(value: Primitive): boolean {
+  return value === false || value === 0 || value === "";
+}
+
+/**
+ * Flattens a deeply nested request payload and returns an object
+ * with only primitive values and non-empty array of primitive values
+ * as per https://github.com/googleapis/googleapis/blob/master/google/api/http.proto
+ * @param  {RequestPayload} requestPayload
+ * @param  {String} path
+ * @return {FlattenedRequestPayload>}
+ */
+function flattenRequestPayload<T extends RequestPayload>(
+  requestPayload: T,
+  path: string = ""
+): FlattenedRequestPayload {
+  return Object.keys(requestPayload).reduce(
+    (acc: T, key: string): T => {
+      const value = requestPayload[key];
+      const newPath = path ? [path, key].join(".") : key;
+
+      const isNonEmptyPrimitiveArray =
+        Array.isArray(value) &&
+        value.every(v => isPrimitive(v)) &&
+        value.length > 0;
+
+      const isNonZeroValuePrimitive =
+        isPrimitive(value) && !isZeroValuePrimitive(value as Primitive);
+
+      let objectToMerge = {};
+
+      if (isPlainObject(value)) {
+        objectToMerge = flattenRequestPayload(value as RequestPayload, newPath);
+      } else if (isNonZeroValuePrimitive || isNonEmptyPrimitiveArray) {
+        objectToMerge = { [newPath]: value };
+      }
+
+      return { ...acc, ...objectToMerge };
+    },
+    {} as T
+  ) as FlattenedRequestPayload;
+}
+
+/**
+ * Renders a deeply nested request payload into a string of URL search
+ * parameters by first flattening the request payload and then removing keys
+ * which are already present in the URL path.
+ * @param  {RequestPayload} requestPayload
+ * @param  {string[]} urlPathParams
+ * @return {string}
+ */
+export function renderURLSearchParams<T extends RequestPayload>(
+  requestPayload: T,
+  urlPathParams: string[] = []
+): string {
+  const flattenedRequestPayload = flattenRequestPayload(requestPayload);
+
+  const urlSearchParams = Object.keys(flattenedRequestPayload).reduce(
+    (acc: string[][], key: string): string[][] => {
+      // key should not be present in the url path as a parameter
+      const value = flattenedRequestPayload[key];
+      if (urlPathParams.find(f => f === key)) {
+        return acc;
+      }
+      return Array.isArray(value)
+        ? [...acc, ...value.map(m => [key, m.toString()])]
+        : (acc = [...acc, [key, value.toString()]]);
+    },
+    [] as string[][]
+  );
+
+  return new URLSearchParams(urlSearchParams).toString();
+}

package/insight.pb.ts

@@ -0,0 +1,42 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+export enum Severity {
+  SEVERITY_UNSPECIFIED = "SEVERITY_UNSPECIFIED",
+  CRITICAL = "CRITICAL",
+  WARNING = "WARNING",
+  INFO = "INFO",
+}
+
+export enum TargetType {
+  TARGET_TYPE_UNSPECIFIED = "TARGET_TYPE_UNSPECIFIED",
+  GLOBAL = "GLOBAL",
+  CLUSTER = "CLUSTER",
+  NAMESPACE = "NAMESPACE",
+  NODE = "NODE",
+  DEPLOYMENT = "DEPLOYMENT",
+  STATEFULSET = "STATEFULSET",
+  DAEMONSET = "DAEMONSET",
+  POD = "POD",
+}
+
+export type AlertSummary = {
+  id?: string
+  groupName?: string
+  groupId?: string
+  ruleName?: string
+  ruleId?: string
+  clusterName?: string
+  namespace?: string
+  targetType?: TargetType
+  target?: string
+  severity?: Severity
+  value?: string
+  notifyResponse?: string
+  description?: string
+  startAt?: string
+  updateAt?: string
+}

package/metric.pb.ts

@@ -0,0 +1,25 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as CommonCommon from "./common.pb"
+import * as fm from "./fetch.pb"
+import * as InsightIoApiInsightV1alpha1Insight from "./insight.pb"
+export type GetAlertsListReq = {
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type GetAlertsListResp = {
+  items?: InsightIoApiInsightV1alpha1Insight.AlertSummary[]
+  pagination?: CommonCommon.Pagination
+}
+
+export class Metric {
+  static GetAlertsList(req: GetAlertsListReq, initReq?: fm.InitReq): Promise<GetAlertsListResp> {
+    return fm.fetchReq<GetAlertsListReq, GetAlertsListResp>(`/apis/mcamel.io/rocketmq/v1alpha1/${req["cluster"]}/${req["namespace"]}/${req["name"]}/alerts?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
+}

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name":"@daocloud-proto/mcamel-rocketmq",
+  "version":"0.0.1",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC"
+}

package/rocketmq.pb.ts

@@ -0,0 +1,389 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as CommonCommon from "./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 Status {
+  Failed = "Failed",
+  Running = "Running",
+  Creating = "Creating",
+}
+
+export enum GetRocketMqListReqSortDir {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+
+export enum GetRocketMqConfReqSortDir {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+
+export enum GetRocketMqParamRespSelectSelectType {
+  Single = "Single",
+  Multiple = "Multiple",
+}
+
+export enum GetRocketMqPodListReqSortDir {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+
+export enum GetRocketMqPodListRespPodStatus {
+  PHASE_UNSPECIFIED = "PHASE_UNSPECIFIED",
+  Unknown = "Unknown",
+  Pending = "Pending",
+  Running = "Running",
+  Succeeded = "Succeeded",
+  Failed = "Failed",
+}
+
+export enum GetRocketMqPodListRespPodType {
+  PodTypeUnknown = "PodTypeUnknown",
+  PodTypePrimary = "PodTypePrimary",
+  PodTypeSecondary = "PodTypeSecondary",
+}
+
+export enum GetRocketMqConfRespItemsParamType {
+  conf = "conf",
+}
+
+export type GetRocketMqUsersReq = {
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type GetRocketMqUsersRespUserItem = {
+  username?: string
+  password?: string
+}
+
+export type GetRocketMqUsersResp = {
+  users?: GetRocketMqUsersRespUserItem[]
+}
+
+export type GetRocketMqListReq = {
+  page?: number
+  pageSize?: number
+  sortDir?: GetRocketMqListReqSortDir
+  sortBy?: string
+  searchKey?: string
+  workspaceId?: number
+  filterCluster?: string
+  filterNamespace?: string
+}
+
+export type GetRocketMqConfReq = {
+  page?: number
+  pageSize?: number
+  sortDir?: GetRocketMqConfReqSortDir
+  sortBy?: string
+  searchKey?: string
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type GetRocketMqParamReq = {
+  cluster?: string
+}
+
+export type CreateRocketMqReqPorts = {
+  name?: string
+  protocol?: string
+  port?: number
+  targetPort?: number
+  nodePort?: number
+}
+
+export type CreateRocketMqReq = {
+  workspaceId?: number
+  cluster?: string
+  namespace?: string
+  name?: string
+  describe?: string
+  version?: string
+  groupSize?: number
+  replicaPerGroup?: number
+  brokerSyncMode?: string
+  rootName?: string
+  rootPassword?: string
+  storageClassName?: string
+  storageCapacity?: string
+  serviceType?: CommonCommon.ServiceType
+  serviceAnnotations?: {[key: string]: string}
+  ports?: CreateRocketMqReqPorts[]
+  cpuRequest?: string
+  cpuLimit?: string
+  memoryRequest?: string
+  memoryLimit?: string
+  externalTrafficPolicy?: CommonCommon.ExternalTrafficPolicy
+  lbTyp?: CommonCommon.LBTyp
+  lbPoolName?: string
+  lbAddress?: string
+  conf?: string
+  nameServiceCpuRequest?: string
+  nameServiceCpuLimit?: string
+  nameServiceMemoryRequest?: string
+  nameServiceMemoryLimit?: string
+  nameServiceStorageClassName?: string
+  nameServiceStorageCapacity?: string
+  isOpenConsole?: boolean
+  consoleServiceType?: CommonCommon.ServiceType
+  consoleNodePort?: number
+  consoleCpuRequest?: string
+  consoleCpuLimit?: string
+  consoleMemoryRequest?: string
+  consoleMemoryLimit?: string
+  consoleExternalTrafficPolicy?: CommonCommon.ExternalTrafficPolicy
+  consoleLbTyp?: CommonCommon.LBTyp
+  consoleLbPoolName?: string
+  consoleLbAddress?: string
+  serviceMonitorInterval?: string
+  affinity?: CommonCommon.Affinity
+}
+
+export type UpdateRocketMqConfReq = {
+  cluster?: string
+  namespace?: string
+  name?: string
+  conf?: string
+}
+
+export type UpdateRocketMqParamsResp = {
+  message?: string
+}
+
+export type UpdateRocketMqConfResp = {
+  message?: string
+}
+
+export type GetRocketMqParamRespSelectDataStringValue = {
+  value?: string
+}
+
+export type GetRocketMqParamRespSelectDataResourceValue = {
+  cpuRequest?: string
+  cpuLimit?: string
+  memoryRequest?: string
+  memoryLimit?: string
+}
+
+export type GetRocketMqParamRespSelectDataIntValue = {
+  value?: number
+}
+
+export type GetRocketMqParamRespSelectDataStorageClassValue = {
+  name?: string
+  allowVolumeExpansion?: boolean
+}
+
+
+type BaseGetRocketMqParamRespSelectData = {
+}
+
+export type GetRocketMqParamRespSelectData = BaseGetRocketMqParamRespSelectData
+  & OneOf<{ sValue: GetRocketMqParamRespSelectDataStringValue; rValue: GetRocketMqParamRespSelectDataResourceValue; iValue: GetRocketMqParamRespSelectDataIntValue; scValue: GetRocketMqParamRespSelectDataStorageClassValue }>
+
+export type GetRocketMqParamRespSelect = {
+  selectType?: GetRocketMqParamRespSelectSelectType
+  data?: GetRocketMqParamRespSelectData[]
+}
+
+export type GetRocketMqParamResp = {
+  version?: GetRocketMqParamRespSelect
+  conf?: GetRocketMqParamRespSelect
+  replicas?: GetRocketMqParamRespSelect
+  resource?: GetRocketMqParamRespSelect
+  storage?: GetRocketMqParamRespSelect
+}
+
+export type GetRocketMqBackupProviderListResp = {
+  provider?: GetRocketMqParamRespSelect
+}
+
+export type CreateRocketMqResp = {
+  message?: string
+}
+
+export type GetRocketMqOperatorVersionListReq = {
+}
+
+export type GetRocketMqOperatorVersionListRespGetRocketMqOperatorVersionListData = {
+  cluster?: string
+  namespace?: string
+  version?: string
+}
+
+export type GetRocketMqOperatorVersionListResp = {
+  items?: GetRocketMqOperatorVersionListRespGetRocketMqOperatorVersionListData[]
+  pagination?: CommonCommon.Pagination
+}
+
+export type DeleteRocketMqReq = {
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type DeleteRocketMqsReq = {
+  data?: DeleteRocketMqReq[]
+}
+
+export type DeleteRocketMqResp = {
+  message?: string
+}
+
+export type DeleteRocketMqsResp = {
+  message?: string
+}
+
+export type GetRocketMqPodListReq = {
+  cluster?: string
+  namespace?: string
+  name?: string
+  page?: number
+  pageSize?: number
+  sortDir?: GetRocketMqPodListReqSortDir
+  sortBy?: string
+  searchKey?: string
+}
+
+export type GetRocketMqPodListRespData = {
+  podName?: string
+  status?: GetRocketMqPodListRespPodStatus
+  ip?: string
+  restart?: number
+  cpuUsage?: number
+  cpuLimit?: number
+  memoryUsage?: number
+  memoryLimit?: number
+  createTimestamp?: string
+  podType?: GetRocketMqPodListRespPodType
+  common?: CommonCommon.PodCommon
+}
+
+export type GetRocketMqPodListResp = {
+  items?: GetRocketMqPodListRespData[]
+  pagination?: CommonCommon.Pagination
+}
+
+export type GetRocketMqGrafanaAddrReq = {
+  cluster?: string
+  namespace?: string
+  name?: string
+  from?: string
+  to?: string
+}
+
+export type GetRocketMqGrafanaAddrResp = {
+  data?: string
+}
+
+export type GetRocketMqReq = {
+  cluster?: string
+  namespace?: string
+  name?: string
+}
+
+export type GetRocketMqResp = {
+  data?: RocketMqItem
+}
+
+export type GetRocketMqConfRespItems = {
+  paramType?: GetRocketMqConfRespItemsParamType
+  paramName?: string
+  value?: string
+}
+
+export type GetRocketMqConfResp = {
+  items?: GetRocketMqConfRespItems[]
+  pagination?: CommonCommon.Pagination
+  conf?: UpdateRocketMqConfReq
+}
+
+export type GetRocketMqListResp = {
+  items?: RocketMqItem[]
+  pagination?: CommonCommon.Pagination
+}
+
+export type RocketMqItemStatus = {
+  status?: Status
+  podsAreReadyNum?: number
+  clusterIPs?: string[]
+  common?: CommonCommon.CommonItemStatus
+  cpuUtilization?: number
+  memoryUtilization?: number
+  avgReplicationLagInSecond?: number
+}
+
+export type RocketMqItemMetadata = {
+  annotations?: {[key: string]: string}
+  creationTimestamp?: string
+  name?: string
+  namespace?: string
+}
+
+export type RocketMqItem = {
+  apiVersion?: string
+  kind?: string
+  metadata?: RocketMqItemMetadata
+  spec?: CreateRocketMqReq
+  status?: RocketMqItemStatus
+}
+
+export class RocketMq {
+  static GetRocketMqList(req: GetRocketMqListReq, initReq?: fm.InitReq): Promise<GetRocketMqListResp> {
+    return fm.fetchReq<GetRocketMqListReq, GetRocketMqListResp>(`/apis/mcamel.io/rocketmq/v1alpha1/${req["workspaceId"]}/rocketmqs?${fm.renderURLSearchParams(req, ["workspaceId"])}`, {...initReq, method: "GET"})
+  }
+  static GetRocketMqOperatorVersionList(req: GetRocketMqOperatorVersionListReq, initReq?: fm.InitReq): Promise<GetRocketMqOperatorVersionListResp> {
+    return fm.fetchReq<GetRocketMqOperatorVersionListReq, GetRocketMqOperatorVersionListResp>(`/apis/mcamel.io/rocketmq/v1alpha1/rocketmq-operator/versions?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+  static GetRocketMq(req: GetRocketMqReq, initReq?: fm.InitReq): Promise<GetRocketMqResp> {
+    return fm.fetchReq<GetRocketMqReq, GetRocketMqResp>(`/apis/mcamel.io/rocketmq/v1alpha1/rocketmq/${req["cluster"]}/${req["namespace"]}/${req["name"]}?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
+  static GetRocketMqParam(req: GetRocketMqParamReq, initReq?: fm.InitReq): Promise<GetRocketMqParamResp> {
+    return fm.fetchReq<GetRocketMqParamReq, GetRocketMqParamResp>(`/apis/mcamel.io/rocketmq/v1alpha1/rocketmq-params/${req["cluster"]}?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+  }
+  static GetRocketMqPodList(req: GetRocketMqPodListReq, initReq?: fm.InitReq): Promise<GetRocketMqPodListResp> {
+    return fm.fetchReq<GetRocketMqPodListReq, GetRocketMqPodListResp>(`/apis/mcamel.io/rocketmq/v1alpha1/rocketmq/${req["cluster"]}/${req["namespace"]}/${req["name"]}/pods?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
+  static GetRocketMqGrafanaAddr(req: GetRocketMqGrafanaAddrReq, initReq?: fm.InitReq): Promise<GetRocketMqGrafanaAddrResp> {
+    return fm.fetchReq<GetRocketMqGrafanaAddrReq, GetRocketMqGrafanaAddrResp>(`/apis/mcamel.io/rocketmq/v1alpha1/rocketmq/${req["cluster"]}/${req["namespace"]}/${req["name"]}/grafana?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
+  static CreateRocketMq(req: CreateRocketMqReq, initReq?: fm.InitReq): Promise<CreateRocketMqResp> {
+    return fm.fetchReq<CreateRocketMqReq, CreateRocketMqResp>(`/apis/mcamel.io/rocketmq/v1alpha1/rocketmq`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+  static GetRocketMqConfs(req: GetRocketMqConfReq, initReq?: fm.InitReq): Promise<GetRocketMqConfResp> {
+    return fm.fetchReq<GetRocketMqConfReq, GetRocketMqConfResp>(`/apis/mcamel.io/rocketmq/v1alpha1/rocketmq/${req["cluster"]}/${req["namespace"]}/${req["name"]}/confs?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
+  static UpdateRocketMqConf(req: UpdateRocketMqConfReq, initReq?: fm.InitReq): Promise<UpdateRocketMqConfResp> {
+    return fm.fetchReq<UpdateRocketMqConfReq, UpdateRocketMqConfResp>(`/apis/mcamel.io/rocketmq/v1alpha1/rocketmq/${req["cluster"]}/${req["namespace"]}/${req["name"]}/conf`, {...initReq, method: "PUT", body: JSON.stringify(req)})
+  }
+  static UpdateRocketMqParams(req: CreateRocketMqReq, initReq?: fm.InitReq): Promise<UpdateRocketMqParamsResp> {
+    return fm.fetchReq<CreateRocketMqReq, UpdateRocketMqParamsResp>(`/apis/mcamel.io/rocketmq/v1alpha1/rocketmq/${req["cluster"]}/${req["namespace"]}/${req["name"]}/params`, {...initReq, method: "PUT", body: JSON.stringify(req)})
+  }
+  static DeleteRocketMq(req: DeleteRocketMqReq, initReq?: fm.InitReq): Promise<DeleteRocketMqResp> {
+    return fm.fetchReq<DeleteRocketMqReq, DeleteRocketMqResp>(`/apis/mcamel.io/rocketmq/v1alpha1/rocketmq/${req["cluster"]}/${req["namespace"]}/${req["name"]}`, {...initReq, method: "DELETE"})
+  }
+  static DeleteRocketMqs(req: DeleteRocketMqsReq, initReq?: fm.InitReq): Promise<DeleteRocketMqsResp> {
+    return fm.fetchReq<DeleteRocketMqsReq, DeleteRocketMqsResp>(`/apis/mcamel.io/rocketmq/v1alpha1/rocketmqs`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+  static GetRocketMqUsers(req: GetRocketMqUsersReq, initReq?: fm.InitReq): Promise<GetRocketMqUsersResp> {
+    return fm.fetchReq<GetRocketMqUsersReq, GetRocketMqUsersResp>(`/apis/mcamel.io/rocketmq/v1alpha1/rocketmq/${req["cluster"]}/${req["namespace"]}/${req["name"]}/users?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
+}

package/version.pb.ts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as fm from "./fetch.pb"
+export type CommonReply = {
+  code?: number
+  msg?: string
+}
+
+export type GetVersionReply = {
+  commonReply?: CommonReply
+  gitCommit?: string
+  gitVersion?: string
+  buildTime?: string
+}
+
+export type Empty = {
+}
+
+export class Version {
+  static Get(req: Empty, initReq?: fm.InitReq): Promise<GetVersionReply> {
+    return fm.fetchReq<Empty, GetVersionReply>(`/apis/mcamel.io/rocketmq/v1alpha1/rocketmq/version?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+}