@gitpod/supervisor-api-grpcweb 0.1.5-mp-configcat-demo.2 → 0.1.5-mp-server-experiments.5

package/lib/notification_pb_service.d.ts

@@ -31,11 +31,41 @@ type NotificationServiceRespond = {
   readonly responseType: typeof notification_pb.RespondResponse;
 };
 
+type NotificationServiceSubscribeActive = {
+  readonly methodName: string;
+  readonly service: typeof NotificationService;
+  readonly requestStream: false;
+  readonly responseStream: true;
+  readonly requestType: typeof notification_pb.SubscribeActiveRequest;
+  readonly responseType: typeof notification_pb.SubscribeActiveResponse;
+};
+
+type NotificationServiceNotifyActive = {
+  readonly methodName: string;
+  readonly service: typeof NotificationService;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof notification_pb.NotifyActiveRequest;
+  readonly responseType: typeof notification_pb.NotifyActiveResponse;
+};
+
+type NotificationServiceNotifyActiveRespond = {
+  readonly methodName: string;
+  readonly service: typeof NotificationService;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof notification_pb.NotifyActiveRespondRequest;
+  readonly responseType: typeof notification_pb.NotifyActiveRespondResponse;
+};
+
 export class NotificationService {
   static readonly serviceName: string;
   static readonly Notify: NotificationServiceNotify;
   static readonly Subscribe: NotificationServiceSubscribe;
   static readonly Respond: NotificationServiceRespond;
+  static readonly SubscribeActive: NotificationServiceSubscribeActive;
+  static readonly NotifyActive: NotificationServiceNotifyActive;
+  static readonly NotifyActiveRespond: NotificationServiceNotifyActiveRespond;
 }
 
 export type ServiceError = { message: string, code: number; metadata: grpc.Metadata }
@@ -89,5 +119,24 @@ export class NotificationServiceClient {
     requestMessage: notification_pb.RespondRequest,
     callback: (error: ServiceError|null, responseMessage: notification_pb.RespondResponse|null) => void
   ): UnaryResponse;
+  subscribeActive(requestMessage: notification_pb.SubscribeActiveRequest, metadata?: grpc.Metadata): ResponseStream<notification_pb.SubscribeActiveResponse>;
+  notifyActive(
+    requestMessage: notification_pb.NotifyActiveRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: notification_pb.NotifyActiveResponse|null) => void
+  ): UnaryResponse;
+  notifyActive(
+    requestMessage: notification_pb.NotifyActiveRequest,
+    callback: (error: ServiceError|null, responseMessage: notification_pb.NotifyActiveResponse|null) => void
+  ): UnaryResponse;
+  notifyActiveRespond(
+    requestMessage: notification_pb.NotifyActiveRespondRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: notification_pb.NotifyActiveRespondResponse|null) => void
+  ): UnaryResponse;
+  notifyActiveRespond(
+    requestMessage: notification_pb.NotifyActiveRespondRequest,
+    callback: (error: ServiceError|null, responseMessage: notification_pb.NotifyActiveRespondResponse|null) => void
+  ): UnaryResponse;
 }
 

package/lib/notification_pb_service.js

@@ -37,6 +37,33 @@ NotificationService.Respond = {
   responseType: notification_pb.RespondResponse
 };
 
+NotificationService.SubscribeActive = {
+  methodName: "SubscribeActive",
+  service: NotificationService,
+  requestStream: false,
+  responseStream: true,
+  requestType: notification_pb.SubscribeActiveRequest,
+  responseType: notification_pb.SubscribeActiveResponse
+};
+
+NotificationService.NotifyActive = {
+  methodName: "NotifyActive",
+  service: NotificationService,
+  requestStream: false,
+  responseStream: false,
+  requestType: notification_pb.NotifyActiveRequest,
+  responseType: notification_pb.NotifyActiveResponse
+};
+
+NotificationService.NotifyActiveRespond = {
+  methodName: "NotifyActiveRespond",
+  service: NotificationService,
+  requestStream: false,
+  responseStream: false,
+  requestType: notification_pb.NotifyActiveRespondRequest,
+  responseType: notification_pb.NotifyActiveRespondResponse
+};
+
 exports.NotificationService = NotificationService;
 
 function NotificationServiceClient(serviceHost, options) {
@@ -145,5 +172,106 @@ NotificationServiceClient.prototype.respond = function respond(requestMessage, m
   };
 };
 
+NotificationServiceClient.prototype.subscribeActive = function subscribeActive(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(NotificationService.SubscribeActive, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onMessage: function (responseMessage) {
+      listeners.data.forEach(function (handler) {
+        handler(responseMessage);
+      });
+    },
+    onEnd: function (status, statusMessage, trailers) {
+      listeners.status.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners.end.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners = null;
+    }
+  });
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
+NotificationServiceClient.prototype.notifyActive = function notifyActive(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(NotificationService.NotifyActive, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+NotificationServiceClient.prototype.notifyActiveRespond = function notifyActiveRespond(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(NotificationService.NotifyActiveRespond, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
 exports.NotificationServiceClient = NotificationServiceClient;
 

package/lib/port_pb.js

@@ -13,13 +13,7 @@
 
 var jspb = require('google-protobuf');
 var goog = jspb;
-var global = (function() {
-  if (this) { return this; }
-  if (typeof window !== 'undefined') { return window; }
-  if (typeof global !== 'undefined') { return global; }
-  if (typeof self !== 'undefined') { return self; }
-  return Function('return this')();
-}.call(null));
+var global = (function() { return this || window || global || self || Function('return this')(); }).call(null);
 
 goog.exportSymbol('proto.supervisor.AutoTunnelRequest', null, global);
 goog.exportSymbol('proto.supervisor.AutoTunnelResponse', null, global);

package/lib/status_pb.d.ts

@@ -447,6 +447,74 @@ export namespace TaskPresentation {
   }
 }
 
+export class ResourcesStatuRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ResourcesStatuRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: ResourcesStatuRequest): ResourcesStatuRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ResourcesStatuRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ResourcesStatuRequest;
+  static deserializeBinaryFromReader(message: ResourcesStatuRequest, reader: jspb.BinaryReader): ResourcesStatuRequest;
+}
+
+export namespace ResourcesStatuRequest {
+  export type AsObject = {
+  }
+}
+
+export class ResourcesStatusResponse extends jspb.Message {
+  hasMemory(): boolean;
+  clearMemory(): void;
+  getMemory(): ResourceStatus | undefined;
+  setMemory(value?: ResourceStatus): void;
+
+  hasCpu(): boolean;
+  clearCpu(): void;
+  getCpu(): ResourceStatus | undefined;
+  setCpu(value?: ResourceStatus): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ResourcesStatusResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: ResourcesStatusResponse): ResourcesStatusResponse.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ResourcesStatusResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ResourcesStatusResponse;
+  static deserializeBinaryFromReader(message: ResourcesStatusResponse, reader: jspb.BinaryReader): ResourcesStatusResponse;
+}
+
+export namespace ResourcesStatusResponse {
+  export type AsObject = {
+    memory?: ResourceStatus.AsObject,
+    cpu?: ResourceStatus.AsObject,
+  }
+}
+
+export class ResourceStatus extends jspb.Message {
+  getUsed(): number;
+  setUsed(value: number): void;
+
+  getLimit(): number;
+  setLimit(value: number): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ResourceStatus.AsObject;
+  static toObject(includeInstance: boolean, msg: ResourceStatus): ResourceStatus.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ResourceStatus, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ResourceStatus;
+  static deserializeBinaryFromReader(message: ResourceStatus, reader: jspb.BinaryReader): ResourceStatus;
+}
+
+export namespace ResourceStatus {
+  export type AsObject = {
+    used: number,
+    limit: number,
+  }
+}
+
 export interface ContentSourceMap {
   FROM_OTHER: 0;
   FROM_BACKUP: 1;