@ludeo/cloud-common 1.1.143 → 1.2.1

package/src/v4/events/ludeo-resource-allocation-failed.ts

@@ -0,0 +1,29 @@
+import { IsUUID } from "class-validator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import { CloudResourceContext } from "../contexts";
+
+export class LudeoResourceAllocationFailedPayload {
+  @IsUUID()
+  ludeoResourceId: string;
+}
+
+export class LudeoResourceAllocationFailedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.ludeo-resource-allocation-failed";
+
+  constructor(
+    payload: LudeoResourceAllocationFailedPayload,
+    context: CloudResourceContext
+  ) {
+    super(LudeoResourceAllocationFailedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => LudeoResourceAllocationFailedPayload)
+  payload: LudeoResourceAllocationFailedPayload;
+}

package/src/v4/events/ludeo-resource-loaded.ts

@@ -0,0 +1,28 @@
+import { IsUUID } from "class-validator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import { CloudResourceContext } from "../contexts";
+
+export class LudeoResourceLoadedPayload {
+  @IsUUID()
+  ludeoResourceId: string;
+}
+
+export class LudeoResourceLoaded extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resources.ludeo-resource-loaded";
+
+  constructor(
+    payload: LudeoResourceLoadedPayload,
+    context: CloudResourceContext
+  ) {
+    super(LudeoResourceLoaded.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => LudeoResourceLoadedPayload)
+  payload: LudeoResourceLoadedPayload;
+}

package/src/v4/events/ludeo-resource-loading-failed.ts

@@ -0,0 +1,28 @@
+import { IsUUID } from "class-validator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import { CloudResourceContext } from "../contexts";
+
+export class LudeoResourceLoadingFailedPayload {
+  @IsUUID()
+  ludeoResourceId: string;
+}
+
+export class LudeoResourceLoadingFailed extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resources.ludeo-resource-loading-failed";
+
+  constructor(
+    payload: LudeoResourceLoadingFailedPayload,
+    context: CloudResourceContext
+  ) {
+    super(LudeoResourceLoadingFailed.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => LudeoResourceLoadingFailedPayload)
+  payload: LudeoResourceLoadingFailedPayload;
+}

package/src/v4/events/machine-allocated-response.ts

@@ -0,0 +1,49 @@
+import { IsUUID, IsEnum } from "class-validator";
+
+import { CloudResourceContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import {
+  AWSProviderSettings,
+  CloudProviderSettings,
+  CloudProvider,
+} from "../types";
+
+export class MachineAllocatedResponsePayload {
+  @IsUUID()
+  machineResourceId: string;
+
+  @IsUUID()
+  machinePoolId: string;
+
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @ValidateNestedType(() => AWSProviderSettings)
+  providerSettings: CloudProviderSettings;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+}
+
+export class MachineAllocatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.machine-allocated-response";
+
+  constructor(
+    payload: MachineAllocatedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(MachineAllocatedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => MachineAllocatedResponsePayload)
+  payload: MachineAllocatedResponsePayload;
+}

package/src/v4/events/machine-allocation-failed-response.ts

@@ -0,0 +1,39 @@
+import { IsUUID, IsString } from "class-validator";
+
+import { CloudResourceContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class MachineAllocationFailedResponsePayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  machinePoolId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @IsString()
+  errorMessage: string;
+}
+
+export class MachineAllocationFailedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.machine-allocation-failed-response";
+
+  constructor(
+    payload: MachineAllocationFailedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(MachineAllocationFailedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => MachineAllocationFailedResponsePayload)
+  payload: MachineAllocationFailedResponsePayload;
+}

package/src/v4/events/machine-deallocated-response.ts

@@ -0,0 +1,42 @@
+import { IsUUID } from "class-validator";
+
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import {
+  CloudResourceContext,
+  CloudSessionContext,
+  getCloudContextType,
+} from "../contexts";
+
+export class MachineDeallocatedResponsePayload {
+  @IsUUID()
+  machinePoolId: string;
+
+  @IsUUID()
+  machineResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @IsUUID()
+  gameResourceId: string;
+}
+
+export class MachineDeallocatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.machine-deallocated-response";
+
+  constructor(
+    payload: MachineDeallocatedResponsePayload,
+    context: CloudSessionContext | CloudResourceContext
+  ) {
+    super(MachineDeallocatedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(getCloudContextType)
+  context: CloudSessionContext | CloudResourceContext;
+
+  @ValidateNestedType(() => MachineDeallocatedResponsePayload)
+  payload: MachineDeallocatedResponsePayload;
+}

package/src/v4/events/machine-deallocation-failed-response.ts

@@ -0,0 +1,46 @@
+import { IsString, IsUUID } from "class-validator";
+
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import {
+  CloudResourceContext,
+  CloudSessionContext,
+  getCloudContextType,
+} from "../contexts";
+
+export class MachineDeallocatedFailedResponsePayload {
+  @IsUUID()
+  machinePoolId: string;
+
+  @IsUUID()
+  machineResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsString()
+  errorMessage: string;
+}
+
+export class MachineDeallocationFailedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-pools.machine-deallocation-failed-response";
+
+  constructor(
+    payload: MachineDeallocatedFailedResponsePayload,
+    context: CloudSessionContext | CloudResourceContext
+  ) {
+    super(MachineDeallocationFailedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(getCloudContextType)
+  context: CloudSessionContext | CloudResourceContext;
+
+  @ValidateNestedType(() => MachineDeallocatedFailedResponsePayload)
+  payload: MachineDeallocatedFailedResponsePayload;
+}

package/src/v4/events/machine-pool-resizing-task.ts

@@ -0,0 +1,35 @@
+import { IsEnum, IsUUID } from "class-validator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators";
+import {
+  AWSProviderSettings,
+  CloudProvider,
+  CloudProviderSettings,
+} from "../types";
+
+export class MachinePoolResizingTaskEventPayload {
+  @ValidateNestedType(() => AWSProviderSettings)
+  providerSettings: CloudProviderSettings;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @IsUUID()
+  machinePoolId: string;
+}
+
+export class MachinePoolResizingTask extends LudeoEvent {
+  public static readonly EVENT_NAME =
+    "cloud-resources.machine-pool-resizing-task";
+
+  constructor(payload: MachinePoolResizingTaskEventPayload, context: never) {
+    super(MachinePoolResizingTask.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  public context: never;
+
+  @ValidateNestedType(() => MachinePoolResizingTaskEventPayload)
+  public payload: MachinePoolResizingTaskEventPayload;
+}

package/src/v4/events/machine-resource-batch-creation-failed-response.ts

@@ -0,0 +1,47 @@
+import { IsArray, IsEnum, IsString, IsUUID } from "class-validator";
+
+import { CloudResourceContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import {
+  AWSProviderSettings,
+  CloudProvider,
+  CloudProviderSettings,
+} from "../types";
+
+export class MachineResourceBatchCreationFailedResponsePayload {
+  @IsArray()
+  machineResourceIds: string[];
+
+  @IsUUID()
+  machinePoolId: string;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @ValidateNestedType(() => AWSProviderSettings)
+  cloudProviderSettings: CloudProviderSettings;
+
+  @IsString()
+  errorMessage: string;
+}
+
+export class MachineResourceBatchCreationFailedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-pools.machine-resource-batch-creation-failed-resposne";
+
+  constructor(
+    payload: MachineResourceBatchCreationFailedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(MachineResourceBatchCreationFailedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => MachineResourceBatchCreationFailedResponsePayload)
+  payload: MachineResourceBatchCreationFailedResponsePayload;
+}

package/src/v4/events/machine-resource-batch-termination-failed-response.ts

@@ -0,0 +1,49 @@
+import { IsArray, IsEnum, IsString, IsUUID } from "class-validator";
+
+import { CloudResourceContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import {
+  AWSProviderSettings,
+  CloudProvider,
+  CloudProviderSettings,
+} from "../types";
+
+export class MachineResourceBatchTerminationFailedResponsePayload {
+  @IsArray()
+  machineResourceIds: string[];
+
+  @IsUUID()
+  machinePoolId: string;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @ValidateNestedType(() => AWSProviderSettings)
+  cloudProviderSettings: CloudProviderSettings;
+
+  @IsString()
+  errorMessage: string;
+}
+
+export class MachineResourceBatchTerminationFailedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-pools.machine-resource-batch-termination-failed-response";
+
+  constructor(
+    payload: MachineResourceBatchTerminationFailedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(MachineResourceBatchTerminationFailedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(
+    () => MachineResourceBatchTerminationFailedResponsePayload
+  )
+  payload: MachineResourceBatchTerminationFailedResponsePayload;
+}

package/src/v4/events/machine-resource-created-response.ts

@@ -0,0 +1,33 @@
+import { IsUUID } from "class-validator";
+
+import { CloudResourceContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class MachineResourceCreatedResponsePayload {
+  @IsUUID()
+  machineResourceId: string;
+
+  @IsUUID()
+  machinePoolId: string;
+}
+
+export class MachineResourceCreatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.machine-resource-created-response";
+
+  constructor(
+    payload: MachineResourceCreatedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(MachineResourceCreatedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => MachineResourceCreatedResponsePayload)
+  payload: MachineResourceCreatedResponsePayload;
+}

package/src/v4/events/machine-resource-creation-failed-response.ts

@@ -0,0 +1,36 @@
+import { IsString, IsUUID } from "class-validator";
+
+import { CloudResourceContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class MachineResourceCreationFailedResponsePayload {
+  @IsUUID()
+  machineResourceId: string;
+
+  @IsUUID()
+  machinePoolId: string;
+
+  @IsString()
+  errorMessage: string;
+}
+
+export class MachineResourceCreationFailedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.machine-resource-creation-failed-response";
+
+  constructor(
+    payload: MachineResourceCreationFailedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(MachineResourceCreationFailedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => MachineResourceCreationFailedResponsePayload)
+  payload: MachineResourceCreationFailedResponsePayload;
+}

package/src/v4/events/machine-resource-terminated-response.ts

@@ -0,0 +1,33 @@
+import { IsUUID } from "class-validator";
+
+import { CloudResourceContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class MachineResourceTerminatedResponsePayload {
+  @IsUUID()
+  machineResourceId: string;
+
+  @IsUUID()
+  machinePoolId: string;
+}
+
+export class MachineResourceTerminatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-pools.machine-resource-terminated-response";
+
+  constructor(
+    payload: MachineResourceTerminatedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(MachineResourceTerminatedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => MachineResourceTerminatedResponsePayload)
+  payload: MachineResourceTerminatedResponsePayload;
+}

package/src/v4/events/machine-resource-updated.ts

@@ -0,0 +1,32 @@
+import { IsUUID } from "class-validator";
+
+import { CloudResourceContext } from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class MachineResourceUpdatedPayload {
+  @IsUUID()
+  machineResourceId: string;
+
+  @IsUUID()
+  machinePoolId: string;
+}
+
+export class MachineResourceUpdated extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.machine-resource-updated";
+
+  constructor(
+    payload: MachineResourceUpdatedPayload,
+    context: CloudResourceContext
+  ) {
+    super(MachineResourceUpdated.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => MachineResourceUpdatedPayload)
+  payload: MachineResourceUpdatedPayload;
+}

package/src/v4/events/monitor-game-resource-task.ts

@@ -0,0 +1,36 @@
+import { IsEnum, IsUUID } from "class-validator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import {
+  AWSResourceProviderSettings,
+  CloudProvider,
+  CloudResourceProviderSettings,
+} from "../types";
+import { ValidateNestedType } from "../../decorators";
+
+export class MonitorGameResourceTaskEventPayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @ValidateNestedType(() => AWSResourceProviderSettings)
+  providerSettings: CloudResourceProviderSettings;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+}
+
+export class MonitorGameResourceTaskEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resources.monitor-game-resource-task";
+
+  constructor(payload: MonitorGameResourceTaskEventPayload) {
+    super(MonitorGameResourceTaskEvent.EVENT_NAME);
+    this.payload = payload;
+  }
+
+  context: never;
+
+  @ValidateNestedType(() => MonitorGameResourceTaskEventPayload)
+  payload: MonitorGameResourceTaskEventPayload;
+}

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

@@ -0,0 +1,41 @@
+import { IsString, IsUUID } from "class-validator";
+
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { CloudResourcesStatusMap, BasePoolAttributes } from "../types";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class PoolStatusEventBasePool {
+  @ValidateNestedType(() => BasePoolAttributes)
+  attributes: BasePoolAttributes;
+
+  statusMap: CloudResourcesStatusMap;
+
+  @IsUUID()
+  poolId: string;
+}
+
+export class PoolStatusEventGamePool extends PoolStatusEventBasePool {
+  @IsUUID()
+  machinePoolId: string;
+}
+
+export class PoolStatusEventPayload {
+  games: PoolStatusEventGamePool[];
+
+  machines: PoolStatusEventBasePool[];
+
+  @IsUUID()
+  requestId: string;
+}
+
+export class PoolStatusEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.pool-status";
+
+  constructor(payload: PoolStatusEventPayload) {
+    super(PoolStatusEvent.EVENT_NAME);
+    this.payload = payload;
+  }
+
+  @ValidateNestedType(() => PoolStatusEventPayload)
+  payload: PoolStatusEventPayload;
+}

package/src/v4/events/prepare-cloud-machine-auth-failed.ts

@@ -0,0 +1,34 @@
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../../infra";
+import { CloudResourceContext } from "../contexts";
+import { IsOptional, IsString } from "class-validator";
+import { CreateGameResourceRequestPayload } from "./create-game-resource-request";
+
+export class PrepareCloudMachineAuthFailedPayload {
+  @IsString()
+  @IsOptional()
+  errorMessage?: string;
+
+  @IsOptional()
+  @ValidateNestedType(() => CreateGameResourceRequestPayload)
+  gameResourceCreationPayload?: CreateGameResourceRequestPayload;
+}
+
+export class PrepareCloudMachineAuthFailed extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.prepare-cloud-machine-auth-failed";
+
+  constructor(
+    payload: PrepareCloudMachineAuthFailedPayload,
+    context: CloudResourceContext
+  ) {
+    super(PrepareCloudMachineAuthFailed.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => PrepareCloudMachineAuthFailedPayload)
+  payload: PrepareCloudMachineAuthFailedPayload;
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+}