增加容器健康检查

back/protos/cron.proto

@@ -2,21 +2,21 @@ syntax = "proto3";
 
 package com.ql.cron;
 
-service CronService {
+service Cron {
   rpc addCron(AddCronRequest) returns (AddCronResponse);
   rpc delCron(DeleteCronRequest) returns (DeleteCronResponse);
 }
 
-message Cron {
+message ICron {
   string id = 1;
   string schedule = 2;
   string command = 3;
 }
 
-message AddCronRequest { repeated Cron crons = 1; }
+message AddCronRequest { repeated ICron crons = 1; }
 
 message AddCronResponse {}
 
 message DeleteCronRequest { repeated string ids = 1; }
 
-message DeleteCronResponse {}
+message DeleteCronResponse {}

back/protos/cron.ts

@@ -15,14 +15,14 @@ import _m0 from 'protobufjs/minimal';
 
 export const protobufPackage = 'com.ql.cron';
 
-export interface Cron {
+export interface ICron {
   id: string;
   schedule: string;
   command: string;
 }
 
 export interface AddCronRequest {
-  crons: Cron[];
+  crons: ICron[];
 }
 
 export interface AddCronResponse {}
@@ -33,12 +33,12 @@ export interface DeleteCronRequest {
 
 export interface DeleteCronResponse {}
 
-function createBaseCron(): Cron {
+function createBaseICron(): ICron {
   return { id: '', schedule: '', command: '' };
 }
 
-export const Cron = {
-  encode(message: Cron, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const ICron = {
+  encode(message: ICron, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.id !== '') {
       writer.uint32(10).string(message.id);
     }
@@ -51,11 +51,11 @@ export const Cron = {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): Cron {
+  decode(input: _m0.Reader | Uint8Array, length?: number): ICron {
     const reader =
       input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseCron();
+    const message = createBaseICron();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -89,7 +89,7 @@ export const Cron = {
     return message;
   },
 
-  fromJSON(object: any): Cron {
+  fromJSON(object: any): ICron {
     return {
       id: isSet(object.id) ? String(object.id) : '',
       schedule: isSet(object.schedule) ? String(object.schedule) : '',
@@ -97,7 +97,7 @@ export const Cron = {
     };
   },
 
-  toJSON(message: Cron): unknown {
+  toJSON(message: ICron): unknown {
     const obj: any = {};
     message.id !== undefined && (obj.id = message.id);
     message.schedule !== undefined && (obj.schedule = message.schedule);
@@ -105,12 +105,12 @@ export const Cron = {
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<Cron>, I>>(base?: I): Cron {
-    return Cron.fromPartial(base ?? {});
+  create<I extends Exact<DeepPartial<ICron>, I>>(base?: I): ICron {
+    return ICron.fromPartial(base ?? {});
   },
 
-  fromPartial<I extends Exact<DeepPartial<Cron>, I>>(object: I): Cron {
-    const message = createBaseCron();
+  fromPartial<I extends Exact<DeepPartial<ICron>, I>>(object: I): ICron {
+    const message = createBaseICron();
     message.id = object.id ?? '';
     message.schedule = object.schedule ?? '';
     message.command = object.command ?? '';
@@ -128,7 +128,7 @@ export const AddCronRequest = {
     writer: _m0.Writer = _m0.Writer.create(),
   ): _m0.Writer {
     for (const v of message.crons) {
-      Cron.encode(v!, writer.uint32(10).fork()).ldelim();
+      ICron.encode(v!, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   },
@@ -146,7 +146,7 @@ export const AddCronRequest = {
             break;
           }
 
-          message.crons.push(Cron.decode(reader, reader.uint32()));
+          message.crons.push(ICron.decode(reader, reader.uint32()));
           continue;
       }
       if ((tag & 7) == 4 || tag == 0) {
@@ -160,7 +160,7 @@ export const AddCronRequest = {
   fromJSON(object: any): AddCronRequest {
     return {
       crons: Array.isArray(object?.crons)
-        ? object.crons.map((e: any) => Cron.fromJSON(e))
+        ? object.crons.map((e: any) => ICron.fromJSON(e))
         : [],
     };
   },
@@ -168,7 +168,7 @@ export const AddCronRequest = {
   toJSON(message: AddCronRequest): unknown {
     const obj: any = {};
     if (message.crons) {
-      obj.crons = message.crons.map((e) => (e ? Cron.toJSON(e) : undefined));
+      obj.crons = message.crons.map((e) => (e ? ICron.toJSON(e) : undefined));
     } else {
       obj.crons = [];
     }
@@ -185,7 +185,7 @@ export const AddCronRequest = {
     object: I,
   ): AddCronRequest {
     const message = createBaseAddCronRequest();
-    message.crons = object.crons?.map((e) => Cron.fromPartial(e)) || [];
+    message.crons = object.crons?.map((e) => ICron.fromPartial(e)) || [];
     return message;
   },
 };
@@ -366,10 +366,10 @@ export const DeleteCronResponse = {
   },
 };
 
-export type CronServiceService = typeof CronServiceService;
-export const CronServiceService = {
+export type CronService = typeof CronService;
+export const CronService = {
   addCron: {
-    path: '/com.ql.cron.CronService/addCron',
+    path: '/com.ql.cron.Cron/addCron',
     requestStream: false,
     responseStream: false,
     requestSerialize: (value: AddCronRequest) =>
@@ -380,7 +380,7 @@ export const CronServiceService = {
     responseDeserialize: (value: Buffer) => AddCronResponse.decode(value),
   },
   delCron: {
-    path: '/com.ql.cron.CronService/delCron',
+    path: '/com.ql.cron.Cron/delCron',
     requestStream: false,
     responseStream: false,
     requestSerialize: (value: DeleteCronRequest) =>
@@ -392,12 +392,12 @@ export const CronServiceService = {
   },
 } as const;
 
-export interface CronServiceServer extends UntypedServiceImplementation {
+export interface CronServer extends UntypedServiceImplementation {
   addCron: handleUnaryCall<AddCronRequest, AddCronResponse>;
   delCron: handleUnaryCall<DeleteCronRequest, DeleteCronResponse>;
 }
 
-export interface CronServiceClient extends Client {
+export interface CronClient extends Client {
   addCron(
     request: AddCronRequest,
     callback: (error: ServiceError | null, response: AddCronResponse) => void,
@@ -439,16 +439,16 @@ export interface CronServiceClient extends Client {
   ): ClientUnaryCall;
 }
 
-export const CronServiceClient = makeGenericClientConstructor(
-  CronServiceService,
-  'com.ql.cron.CronService',
+export const CronClient = makeGenericClientConstructor(
+  CronService,
+  'com.ql.cron.Cron',
 ) as unknown as {
   new (
     address: string,
     credentials: ChannelCredentials,
     options?: Partial<ClientOptions>,
-  ): CronServiceClient;
-  service: typeof CronServiceService;
+  ): CronClient;
+  service: typeof CronService;
 };
 
 type Builtin =

back/protos/health.proto

@@ -0,0 +1,22 @@
+syntax = "proto3";
+
+package com.ql.health;
+
+message HealthCheckRequest {
+  string service = 1;
+}
+
+message HealthCheckResponse {
+  enum ServingStatus {
+    UNKNOWN = 0;
+    SERVING = 1;
+    NOT_SERVING = 2;
+    SERVICE_UNKNOWN = 3;
+  }
+  ServingStatus status = 1;
+}
+
+service Health {
+  rpc Check(HealthCheckRequest) returns (HealthCheckResponse);
+  rpc Watch(HealthCheckRequest) returns (stream HealthCheckResponse);
+}

back/protos/health.ts

@@ -0,0 +1,317 @@
+/* eslint-disable */
+import {
+  CallOptions,
+  ChannelCredentials,
+  Client,
+  ClientOptions,
+  ClientReadableStream,
+  ClientUnaryCall,
+  handleServerStreamingCall,
+  handleUnaryCall,
+  makeGenericClientConstructor,
+  Metadata,
+  ServiceError,
+  UntypedServiceImplementation,
+} from '@grpc/grpc-js';
+import _m0 from 'protobufjs/minimal';
+
+export const protobufPackage = 'com.ql.health';
+
+export interface HealthCheckRequest {
+  service: string;
+}
+
+export interface HealthCheckResponse {
+  status: HealthCheckResponse_ServingStatus;
+}
+
+export enum HealthCheckResponse_ServingStatus {
+  UNKNOWN = 0,
+  SERVING = 1,
+  NOT_SERVING = 2,
+  SERVICE_UNKNOWN = 3,
+  UNRECOGNIZED = -1,
+}
+
+export function healthCheckResponse_ServingStatusFromJSON(
+  object: any,
+): HealthCheckResponse_ServingStatus {
+  switch (object) {
+    case 0:
+    case 'UNKNOWN':
+      return HealthCheckResponse_ServingStatus.UNKNOWN;
+    case 1:
+    case 'SERVING':
+      return HealthCheckResponse_ServingStatus.SERVING;
+    case 2:
+    case 'NOT_SERVING':
+      return HealthCheckResponse_ServingStatus.NOT_SERVING;
+    case 3:
+    case 'SERVICE_UNKNOWN':
+      return HealthCheckResponse_ServingStatus.SERVICE_UNKNOWN;
+    case -1:
+    case 'UNRECOGNIZED':
+    default:
+      return HealthCheckResponse_ServingStatus.UNRECOGNIZED;
+  }
+}
+
+export function healthCheckResponse_ServingStatusToJSON(
+  object: HealthCheckResponse_ServingStatus,
+): string {
+  switch (object) {
+    case HealthCheckResponse_ServingStatus.UNKNOWN:
+      return 'UNKNOWN';
+    case HealthCheckResponse_ServingStatus.SERVING:
+      return 'SERVING';
+    case HealthCheckResponse_ServingStatus.NOT_SERVING:
+      return 'NOT_SERVING';
+    case HealthCheckResponse_ServingStatus.SERVICE_UNKNOWN:
+      return 'SERVICE_UNKNOWN';
+    case HealthCheckResponse_ServingStatus.UNRECOGNIZED:
+    default:
+      return 'UNRECOGNIZED';
+  }
+}
+
+function createBaseHealthCheckRequest(): HealthCheckRequest {
+  return { service: '' };
+}
+
+export const HealthCheckRequest = {
+  encode(
+    message: HealthCheckRequest,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.service !== '') {
+      writer.uint32(10).string(message.service);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): HealthCheckRequest {
+    const reader =
+      input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseHealthCheckRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag != 10) {
+            break;
+          }
+
+          message.service = reader.string();
+          continue;
+      }
+      if ((tag & 7) == 4 || tag == 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): HealthCheckRequest {
+    return { service: isSet(object.service) ? String(object.service) : '' };
+  },
+
+  toJSON(message: HealthCheckRequest): unknown {
+    const obj: any = {};
+    message.service !== undefined && (obj.service = message.service);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<HealthCheckRequest>, I>>(
+    base?: I,
+  ): HealthCheckRequest {
+    return HealthCheckRequest.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<HealthCheckRequest>, I>>(
+    object: I,
+  ): HealthCheckRequest {
+    const message = createBaseHealthCheckRequest();
+    message.service = object.service ?? '';
+    return message;
+  },
+};
+
+function createBaseHealthCheckResponse(): HealthCheckResponse {
+  return { status: 0 };
+}
+
+export const HealthCheckResponse = {
+  encode(
+    message: HealthCheckResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.status !== 0) {
+      writer.uint32(8).int32(message.status);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): HealthCheckResponse {
+    const reader =
+      input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseHealthCheckResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag != 8) {
+            break;
+          }
+
+          message.status = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) == 4 || tag == 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): HealthCheckResponse {
+    return {
+      status: isSet(object.status)
+        ? healthCheckResponse_ServingStatusFromJSON(object.status)
+        : 0,
+    };
+  },
+
+  toJSON(message: HealthCheckResponse): unknown {
+    const obj: any = {};
+    message.status !== undefined &&
+      (obj.status = healthCheckResponse_ServingStatusToJSON(message.status));
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<HealthCheckResponse>, I>>(
+    base?: I,
+  ): HealthCheckResponse {
+    return HealthCheckResponse.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<HealthCheckResponse>, I>>(
+    object: I,
+  ): HealthCheckResponse {
+    const message = createBaseHealthCheckResponse();
+    message.status = object.status ?? 0;
+    return message;
+  },
+};
+
+export type HealthService = typeof HealthService;
+export const HealthService = {
+  check: {
+    path: '/com.ql.health.Health/Check',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value: HealthCheckRequest) =>
+      Buffer.from(HealthCheckRequest.encode(value).finish()),
+    requestDeserialize: (value: Buffer) => HealthCheckRequest.decode(value),
+    responseSerialize: (value: HealthCheckResponse) =>
+      Buffer.from(HealthCheckResponse.encode(value).finish()),
+    responseDeserialize: (value: Buffer) => HealthCheckResponse.decode(value),
+  },
+  watch: {
+    path: '/com.ql.health.Health/Watch',
+    requestStream: false,
+    responseStream: true,
+    requestSerialize: (value: HealthCheckRequest) =>
+      Buffer.from(HealthCheckRequest.encode(value).finish()),
+    requestDeserialize: (value: Buffer) => HealthCheckRequest.decode(value),
+    responseSerialize: (value: HealthCheckResponse) =>
+      Buffer.from(HealthCheckResponse.encode(value).finish()),
+    responseDeserialize: (value: Buffer) => HealthCheckResponse.decode(value),
+  },
+} as const;
+
+export interface HealthServer extends UntypedServiceImplementation {
+  check: handleUnaryCall<HealthCheckRequest, HealthCheckResponse>;
+  watch: handleServerStreamingCall<HealthCheckRequest, HealthCheckResponse>;
+}
+
+export interface HealthClient extends Client {
+  check(
+    request: HealthCheckRequest,
+    callback: (
+      error: ServiceError | null,
+      response: HealthCheckResponse,
+    ) => void,
+  ): ClientUnaryCall;
+  check(
+    request: HealthCheckRequest,
+    metadata: Metadata,
+    callback: (
+      error: ServiceError | null,
+      response: HealthCheckResponse,
+    ) => void,
+  ): ClientUnaryCall;
+  check(
+    request: HealthCheckRequest,
+    metadata: Metadata,
+    options: Partial<CallOptions>,
+    callback: (
+      error: ServiceError | null,
+      response: HealthCheckResponse,
+    ) => void,
+  ): ClientUnaryCall;
+  watch(
+    request: HealthCheckRequest,
+    options?: Partial<CallOptions>,
+  ): ClientReadableStream<HealthCheckResponse>;
+  watch(
+    request: HealthCheckRequest,
+    metadata?: Metadata,
+    options?: Partial<CallOptions>,
+  ): ClientReadableStream<HealthCheckResponse>;
+}
+
+export const HealthClient = makeGenericClientConstructor(
+  HealthService,
+  'com.ql.health.Health',
+) as unknown as {
+  new (
+    address: string,
+    credentials: ChannelCredentials,
+    options?: Partial<ClientOptions>,
+  ): HealthClient;
+  service: typeof HealthService;
+};
+
+type Builtin =
+  | Date
+  | Function
+  | Uint8Array
+  | string
+  | number
+  | boolean
+  | undefined;
+
+export type DeepPartial<T> = T extends Builtin
+  ? T
+  : T extends Array<infer U>
+  ? Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U>
+  ? ReadonlyArray<DeepPartial<U>>
+  : T extends {}
+  ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin
+  ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & {
+      [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+    };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}