@ludeo/cloud-common 1.0.0

package/src/events/create-cloud-resource-request.event.ts

@@ -0,0 +1,45 @@
+import { IsEnum, IsString, IsUUID } from "class-validator";
+import { CreateCloudResourceRequestContext } from "../contexts/create-cloud-resource-request-context";
+import { LudeoEvent } from "../infra/ludeo-event";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+import {
+  AWSResourceCreationConfig,
+  CloudProvider,
+  CloudResourceCreationConfig,
+} from "../types";
+
+export class CreateCloudResourceRequestPayload {
+  @IsUUID()
+  poolId: string;
+
+  @IsUUID()
+  resourceId: string;
+
+  @ValidateNestedType(() => AWSResourceCreationConfig)
+  providerSettings: CloudResourceCreationConfig;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @IsString()
+  cloudToken: string;
+}
+
+export class CreateCloudResourceRequestEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.create-cloud-resource-request";
+
+  constructor(
+    payload: CreateCloudResourceRequestPayload,
+    context: CreateCloudResourceRequestContext
+  ) {
+    super(CreateCloudResourceRequestEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CreateCloudResourceRequestContext)
+  context: CreateCloudResourceRequestContext;
+
+  @ValidateNestedType(() => CreateCloudResourceRequestPayload)
+  payload: CreateCloudResourceRequestPayload;
+}

package/src/events/index.ts

@@ -0,0 +1,23 @@
+export * from "./allocate-cloud-resource-request.event";
+export * from "./allocate-cloud-session-failed.event";
+export * from "./allocate-cloud-session-request.event";
+export * from "./allocate-pool-item-failed.event";
+export * from "./allocate-pool-item-request.event";
+export * from "./cloud-resource-allocated.event";
+export * from "./cloud-resource-created.event";
+export * from "./cloud-resource-creation-failed.event";
+export * from "./cloud-resource-status.event";
+export * from "./cloud-session-allocated.event";
+export * from "./cloud-session-ended.event";
+export * from "./create-cloud-resource-request.event";
+export * from "./monitor-pool-task.event";
+export * from "./pool-created.event";
+export * from "./pool-item-allocated.event";
+export * from "./pool-resize-success.event";
+export * from "./pool-status.event";
+export * from "./pool-updated.event";
+export * from "./remove-scheduled-task-request.event";
+export * from "./resize-pool-request.event";
+export * from "./schedule-task-request.event";
+export * from "./set-pool.event";
+export * from "./token-required.event";

package/src/events/monitor-pool-task.event.ts

@@ -0,0 +1,21 @@
+import { IsUUID } from "class-validator";
+import { LudeoEvent } from "../infra/ludeo-event";
+
+export class MonitorPoolTaskEventPayload {
+  @IsUUID()
+  poolId: string;
+}
+
+export class MonitorPoolTaskEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.monitor-pool-task";
+
+  constructor(payload: MonitorPoolTaskEventPayload, context: never) {
+    super(MonitorPoolTaskEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  context: never;
+
+  payload: MonitorPoolTaskEventPayload;
+}

package/src/events/pool-created.event.ts

@@ -0,0 +1,20 @@
+import { LudeoEvent } from "../infra/ludeo-event";
+import { PoolContext } from "../contexts/pool-context";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+import { CloudPool } from "../models/cloud-pool";
+
+export class PoolCreatedEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.pool-created";
+
+  constructor(payload: CloudPool, context: PoolContext) {
+    super(PoolCreatedEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => PoolContext)
+  context: PoolContext;
+
+  @ValidateNestedType(() => CloudPool)
+  payload: CloudPool;
+}

package/src/events/pool-item-allocated.event.ts

@@ -0,0 +1,20 @@
+import { CloudSessionContext } from "../contexts/cloud-session-context";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../infra/ludeo-event";
+import { PoolItemAllocatedPayload } from "../types";
+
+export class PoolItemAllocatedEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.pool-item-allocated";
+
+  constructor(payload: PoolItemAllocatedPayload, context: CloudSessionContext) {
+    super(PoolItemAllocatedEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+
+  @ValidateNestedType(() => PoolItemAllocatedPayload)
+  payload: PoolItemAllocatedPayload;
+}

package/src/events/pool-resize-success.event.ts

@@ -0,0 +1,25 @@
+import { IsUUID } from "class-validator";
+import { LudeoEvent } from "../infra/ludeo-event";
+import { PoolContext } from "../contexts/pool-context";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+
+export class PoolResizeSuccessEventPayload {
+  @IsUUID()
+  poolId: string;
+}
+
+export class PoolResizeSuccessEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resources.pool-resize-success";
+
+  constructor(payload: PoolResizeSuccessEventPayload, context: PoolContext) {
+    super(PoolResizeSuccessEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => PoolContext)
+  context: PoolContext;
+
+  @ValidateNestedType(() => PoolResizeSuccessEventPayload)
+  payload: PoolResizeSuccessEventPayload;
+}

package/src/events/pool-status.event.ts

@@ -0,0 +1,30 @@
+import { IsObject, IsString, IsUUID, ValidateNested } from "class-validator";
+import { CloudPoolStatus, CloudResourcesStatusMap } from "../types";
+import { LudeoEvent } from "../infra/ludeo-event";
+import { PoolContext } from "../contexts/pool-context";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+
+export class PoolStatusEventPayload {
+  @IsUUID()
+  poolId: string;
+  @IsString()
+  state: CloudPoolStatus;
+  @IsObject()
+  resources: CloudResourcesStatusMap;
+}
+
+export class PoolStatusEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.pool-status";
+
+  constructor(payload: PoolStatusEventPayload, context: PoolContext) {
+    super(PoolStatusEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => PoolContext)
+  context: PoolContext;
+
+  @ValidateNestedType(() => PoolStatusEventPayload)
+  payload: PoolStatusEventPayload;
+}

package/src/events/pool-updated.event.ts

@@ -0,0 +1,20 @@
+import { LudeoEvent } from "../infra/ludeo-event";
+import { PoolContext } from "../contexts/pool-context";
+import { CloudPool } from "../models/cloud-pool";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+
+export class PoolUpdatedEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.pool-updated";
+
+  constructor(payload: CloudPool, context: PoolContext) {
+    super(PoolUpdatedEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => PoolContext)
+  context: PoolContext;
+
+  @ValidateNestedType(() => CloudPool)
+  payload: CloudPool;
+}

package/src/events/remove-scheduled-task-request.event.ts

@@ -0,0 +1,22 @@
+import { IsString, ValidateNested } from "class-validator";
+import { LudeoEvent } from "../infra/ludeo-event";
+
+class RemoveScheduledTaskRequestEventData {
+  @IsString()
+  key: string;
+}
+
+export class RemoveScheduledTaskRequest extends LudeoEvent {
+  static readonly EVENT_NAME = "task-scheduler.remove-scheduled-task-request";
+
+  constructor(payload: RemoveScheduledTaskRequestEventData, context?: never) {
+    super(RemoveScheduledTaskRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  context?: never;
+
+  @ValidateNested()
+  payload: RemoveScheduledTaskRequestEventData;
+}

package/src/events/resize-pool-request.event.ts

@@ -0,0 +1,31 @@
+import { IsEnum, IsNumber, IsUUID } from "class-validator";
+import { LudeoEvent } from "../infra/ludeo-event";
+import { PoolContext } from "../contexts/pool-context";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+import { CloudPoolConfiguration, CloudProvider } from "../types";
+
+export class ResizePoolRequestEventPayload extends CloudPoolConfiguration {
+  providerSettings: any;
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+  @IsUUID()
+  poolId: string;
+  @IsNumber()
+  desiredSize: number;
+}
+
+export class ResizePoolRequestEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.pool-resize-request";
+
+  constructor(payload: ResizePoolRequestEventPayload, context: PoolContext) {
+    super(ResizePoolRequestEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => PoolContext)
+  context: PoolContext;
+
+  @ValidateNestedType(() => ResizePoolRequestEventPayload)
+  payload: ResizePoolRequestEventPayload;
+}

package/src/events/schedule-task-request.event.ts

@@ -0,0 +1,50 @@
+import { IsOptional, IsString, ValidateNested } from "class-validator";
+import { LudeoEvent } from "../infra/ludeo-event";
+
+export class SchedulingData {
+  repeat?: number; // number of times to repeat the task. null - no repeat, 0 (endless), 1, 2...
+  interval?: number; // the time interval between repeats in milliseconds
+  retries?: number; // number of retries in case of failure. default 3
+}
+
+export enum JobType {
+  KafkaEvent = "KAFKA_EVENT",
+}
+
+export class KafkaEventJobData {
+  @IsString()
+  eventTopic: string;
+  eventData: any;
+}
+
+export class Job {
+  @IsString()
+  type: JobType;
+  @ValidateNested()
+  jobData: KafkaEventJobData;
+}
+
+class ScheduleTaskRequestEventData {
+  @IsString()
+  key: string;
+  @IsOptional()
+  sourceService?: string;
+  @ValidateNested()
+  scheduling: SchedulingData;
+  @ValidateNested()
+  job: Job;
+}
+export class ScheduleTaskRequest extends LudeoEvent {
+  static readonly EVENT_NAME = "task-scheduler.schedule-task-request";
+
+  constructor(payload: ScheduleTaskRequestEventData, context?: never) {
+    super(ScheduleTaskRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  context?: never;
+
+  @ValidateNested()
+  payload: ScheduleTaskRequestEventData;
+}

package/src/events/set-pool.event.ts

@@ -0,0 +1,20 @@
+import { PoolContext } from "../contexts/pool-context";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../infra/ludeo-event";
+import { CloudPoolConfiguration } from "../types";
+
+export class SetPoolEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.set-pool";
+
+  constructor(payload: Partial<CloudPoolConfiguration>, context: PoolContext) {
+    super(SetPoolEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => PoolContext)
+  context: PoolContext;
+
+  @ValidateNestedType(() => CloudPoolConfiguration)
+  payload: Partial<CloudPoolConfiguration>;
+}

package/src/events/token-required.event.ts

@@ -0,0 +1,32 @@
+import { LudeoEvent } from "../infra/ludeo-event";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+
+export class TokenRequiredEventData {
+  defaultUser: string;
+  authSource: string;
+}
+
+export class TokenRequiredEventPayload {
+  id: string;
+  type: string;
+  userId: string;
+  expireAt: number;
+  quota: number;
+  isUnique: boolean;
+  data: TokenRequiredEventData;
+}
+
+export class TokenRequired extends LudeoEvent {
+  static readonly EVENT_NAME = "tokens.token-required";
+
+  @ValidateNestedType(() => TokenRequiredEventPayload)
+  payload: TokenRequiredEventPayload;
+
+  context: never;
+
+  constructor(payload: TokenRequiredEventPayload, context?: never) {
+    super(TokenRequired.EVENT_NAME);
+    this.payload = payload;
+    this.context = context as never;
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./contexts";
+export * from "./models";
+export * from "./events";
+export * from "./types";

package/src/infra/ludeo-event.ts

@@ -0,0 +1,22 @@
+import { IsInt, IsNotEmpty, IsString, IsUUID } from "class-validator";
+
+export class LudeoEvent {
+  constructor(eventName: string) {
+    this.eventName = eventName;
+    this.timestamp = Date.now();
+    this.eventId = crypto.randomUUID();
+  }
+
+  @IsUUID()
+  eventId: string;
+
+  @IsString()
+  eventVersion = "3.0";
+
+  @IsString()
+  @IsNotEmpty()
+  eventName: string;
+
+  @IsInt()
+  timestamp: number;
+}

package/src/models/cloud-pool.ts

@@ -0,0 +1,14 @@
+import {
+  CloudPoolConfiguration,
+  CloudPoolStatus,
+  CloudResourcesMap,
+} from "../types";
+
+export class CloudPool {
+  id: string;
+  status: CloudPoolStatus;
+  createdAt: number;
+  updatedAt?: number;
+  config: CloudPoolConfiguration;
+  resources?: CloudResourcesMap;
+}

package/src/models/index.ts

@@ -0,0 +1 @@
+export * from "./cloud-pool";

package/src/types/index.ts

@@ -0,0 +1,122 @@
+import {
+  IsDefined,
+  IsUUID,
+  IsString,
+  IsNotEmpty,
+  IsOptional,
+  IsNumber,
+  IsEnum,
+} from "class-validator";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+import { GameCast } from "@ludeo/aws-gamecast-sdk";
+
+export class AWSRequestData {
+  @IsString()
+  @IsNotEmpty()
+  signalRequest: string;
+}
+
+export type CloudProviderRequest = AWSRequestData;
+
+export class CloudProviderRequestData {
+  @IsUUID()
+  authToken: string;
+
+  @IsUUID()
+  appToken: string;
+
+  @IsDefined()
+  @ValidateNestedType(() => AWSRequestData)
+  cloudProviderRequest: CloudProviderRequest;
+}
+
+export enum CloudProvider {
+  AWS = "aws",
+}
+
+export class AWSResourceCreationConfig {
+  streamGroupId: string;
+  identifier: GameCast.Identifier;
+  additionalEnvironmentVariables?: GameCast.EnvironmentVariables;
+  protocol?: GameCast.Protocol;
+  connectionTimeoutSeconds?: GameCast.ConnectionTimeoutSeconds;
+  sessionLengthSeconds?: GameCast.SessionLengthSeconds;
+  applicationIdentifier?: GameCast.Identifier;
+  region?: string;
+}
+
+export type CloudResourceCreationConfig = AWSResourceCreationConfig;
+
+export enum CloudResourceStatus {
+  Allocated = "allocated",
+  Available = "available",
+  Creating = "creating",
+  Allocating = "allocating",
+  Error = "error",
+  Terminated = "terminated",
+  Terminating = "terminating",
+}
+
+export class AllocateCloudResourceRequestData {
+  providerSettings: CloudResourceCreationConfig;
+  requestData: CloudProviderRequestData;
+}
+
+export class AwsAllocationData {
+  streamGroupId: string;
+  streamSessionId: string;
+  signalResponse: string;
+}
+
+export type CloudProviderAllocationData = AwsAllocationData;
+
+export class AWSResourceProviderSettings {
+  streamSessionId: string;
+  streamGroupId: string;
+}
+
+export class AWSCreationResponse {
+  @IsOptional()
+  signalResponse?: GameCast.SignalResponse;
+
+  @IsString()
+  @IsNotEmpty()
+  streamSessionId: string;
+}
+
+export type CreationResponse = AWSCreationResponse;
+
+export enum CloudPoolStatus {
+  Active = "active",
+  Scaling = "scaling",
+  Terminated = "terminated",
+}
+
+export class CloudPoolConfiguration {
+  providerSettings?: CloudResourceCreationConfig;
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+  @IsUUID()
+  poolId: string;
+  poolScaleConfiguration: PoolScaleConfiguration;
+}
+
+export type CloudResourcesMap = Record<string, { status: CloudResourceStatus }>;
+
+export class PoolScaleConfiguration {
+  @IsNumber()
+  size: number;
+}
+
+export class PoolItemAllocatedPayload {
+  @ValidateNestedType(() => AwsAllocationData)
+  allocationData?: CloudProviderAllocationData;
+}
+
+export type CloudResourcesStatusMap = Record<CloudResourceStatus, number>;
+
+export class AllocationRequestData {
+  authToken: string;
+  appToken: string;
+  cloudProviderRequest: CloudProviderRequest;
+}

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2021",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false,
+    "typeRoots": ["src/common/aerospike", "./node_modules/@types"],
+    "paths": {
+      "*": ["src/types/*"]
+    }
+  },
+  "include": ["src/**/*", "test/**/*"],
+  "watchOptions": {
+    // Use a dynamic polling instead of system’s native events for file changes.
+    "watchFile": "dynamicPriorityPolling",
+    "watchDirectory": "dynamicPriorityPolling",
+    "excludeDirectories": ["**/node_modules", "dist"]
+  }
+}