@ludeo/cloud-common 1.1.143 → 1.2.1

package/src/v4/events/game-resource-allocation-timeout-task.ts

@@ -0,0 +1,26 @@
+import { IsUUID } from "class-validator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators";
+
+export class GameResourceAllocationTimeoutTaskPayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+}
+
+export class GameResourceAllocationTimeoutTask extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-pools.game-resource-allocation-timeout-task";
+
+  constructor(payload: GameResourceAllocationTimeoutTaskPayload) {
+    super(GameResourceAllocationTimeoutTask.EVENT_NAME);
+    this.payload = payload;
+  }
+
+  context: never;
+
+  @ValidateNestedType(() => GameResourceAllocationTimeoutTaskPayload)
+  payload: GameResourceAllocationTimeoutTaskPayload;
+}

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

@@ -0,0 +1,43 @@
+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 {
+  AWSResourceProviderSettings,
+  CloudProvider,
+  CloudResourceProviderSettings,
+} from "../types";
+
+export class GameResourceCreatedResponsePayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @ValidateNestedType(() => AWSResourceProviderSettings)
+  resourceProviderSettings: CloudResourceProviderSettings;
+}
+
+export class GameResourceCreatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resources.game-resource-created-response";
+
+  constructor(
+    payload: GameResourceCreatedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(GameResourceCreatedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => GameResourceCreatedResponsePayload)
+  payload: GameResourceCreatedResponsePayload;
+}

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

@@ -0,0 +1,36 @@
+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 GameResourceCreationFailedResponsePayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @IsString()
+  errorMessage: string;
+}
+
+export class GameResourceCreationFailedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.game-resource-creation-failed-response";
+
+  constructor(
+    payload: GameResourceCreationFailedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(GameResourceCreationFailedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => GameResourceCreationFailedResponsePayload)
+  payload: GameResourceCreationFailedResponsePayload;
+}

package/src/v4/events/game-resource-ready-for-creation-failed.ts

@@ -0,0 +1,35 @@
+import { LudeoEvent } from "../../infra";
+import { IsString, IsUUID } from "class-validator";
+import { ValidateNestedType } from "../../decorators";
+import { CloudResourceContext } from "../contexts";
+
+export class GameResourceReadyForCreationFailedPayload {
+  @IsUUID()
+  gamePoolId: string;
+
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsString()
+  errorMessage: string;
+}
+
+export class GameResourceReadyForCreationFailed extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.game-resource-ready-for-creation-failed";
+
+  constructor(
+    payload: GameResourceReadyForCreationFailedPayload,
+    context: CloudResourceContext,
+  ) {
+    super(GameResourceReadyForCreationFailed.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => GameResourceReadyForCreationFailedPayload)
+  payload: GameResourceReadyForCreationFailedPayload;
+}

package/src/v4/events/game-resource-ready-for-creation.ts

@@ -0,0 +1,37 @@
+import { LudeoEvent } from "../../infra";
+import { ValidateNestedType } from "../../decorators";
+import { CloudResourceContext } from "../contexts";
+import {
+  AWSResourceProviderSettings,
+  CloudProviderSettings,
+  CloudResourceProviderSettings,
+} from "../types";
+import { CreateGameResourceRequestPayload } from "./create-game-resource-request";
+
+export class GameResourceReadyForCreationPayload {
+  @ValidateNestedType(() => AWSResourceProviderSettings)
+  providerSettings: CloudResourceProviderSettings;
+
+  @ValidateNestedType(() => CreateGameResourceRequestPayload)
+  creationPayload: CreateGameResourceRequestPayload;
+}
+
+export class GameResourceReadyForCreation extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.game-resource-ready-for-creation";
+
+  constructor(
+    payload: GameResourceReadyForCreationPayload,
+    context: CloudResourceContext
+  ) {
+    super(GameResourceReadyForCreation.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => GameResourceReadyForCreationPayload)
+  payload: GameResourceReadyForCreationPayload;
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+}

package/src/v4/events/game-resource-status-changed.ts

@@ -0,0 +1,47 @@
+import { IsOptional, IsString, IsUUID } from "class-validator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { CloudResourceContext } from "../contexts/cloud-resource-context";
+import { AWSResourceProviderSettings, CloudResourceStatus } from "../types";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class GameResourceStatusChangedEventPayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @ValidateNestedType(() => AWSResourceProviderSettings)
+  providerSettings: AWSResourceProviderSettings;
+
+  @IsString()
+  status: CloudResourceStatus;
+
+  @IsOptional()
+  @IsString()
+  previousStatus?: CloudResourceStatus;
+
+  @IsOptional()
+  @IsString()
+  error?: string;
+}
+
+export class GameResourceStatusChangedEvent extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resource-monitor.game-resource-status-changed";
+
+  constructor(
+    payload: GameResourceStatusChangedEventPayload,
+    context: CloudResourceContext,
+  ) {
+    super(GameResourceStatusChangedEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => GameResourceStatusChangedEventPayload)
+  payload: GameResourceStatusChangedEventPayload;
+}

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

@@ -0,0 +1,40 @@
+import { IsUUID, IsBoolean } from "class-validator";
+
+import {
+  CloudResourceContext,
+  CloudSessionContext,
+  getCloudContextType,
+} from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class GameResourceTerminatedResponsePayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @IsBoolean()
+  shouldDeallocateMachineResource: boolean;
+}
+
+export class GameResourceTerminatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.game-resource-terminated-response";
+
+  constructor(
+    payload: GameResourceTerminatedResponsePayload,
+    context: CloudSessionContext | CloudResourceContext
+  ) {
+    super(GameResourceTerminatedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(getCloudContextType)
+  context: CloudSessionContext | CloudResourceContext;
+
+  @ValidateNestedType(() => GameResourceTerminatedResponsePayload)
+  payload: GameResourceTerminatedResponsePayload;
+}

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

@@ -0,0 +1,43 @@
+import { IsUUID, IsString, IsBoolean } from "class-validator";
+
+import {
+  CloudResourceContext,
+  CloudSessionContext,
+  getCloudContextType,
+} from "../contexts";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class GameResourceTerminationFailedResponsePayload {
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsUUID()
+  gamePoolId: string;
+
+  @IsBoolean()
+  shouldDeallocateMachineResource: boolean;
+
+  @IsString()
+  errorMessage: string;
+}
+
+export class GameResourceTerminationFailedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.game-resource-termination-failed-response";
+
+  constructor(
+    payload: GameResourceTerminationFailedResponsePayload,
+    context: CloudSessionContext | CloudResourceContext
+  ) {
+    super(GameResourceTerminationFailedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(getCloudContextType)
+  context: CloudSessionContext | CloudResourceContext;
+
+  @ValidateNestedType(() => GameResourceTerminationFailedResponsePayload)
+  payload: GameResourceTerminationFailedResponsePayload;
+}

package/src/v4/events/game-terminated-response.ts

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

package/src/v4/events/game-termination-failed-response.ts

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

package/src/v4/events/gameplay-waiting-for-user.ts

@@ -0,0 +1,28 @@
+import { IsString, IsUUID } from "class-validator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import { CloudResourceContext } from "../contexts";
+
+export class GameplayWaitingForUserPayload {
+  @IsUUID()
+  ludeoResourceId: string;
+}
+
+export class GameplayWaitingForUser extends LudeoEvent {
+  static readonly EVENT_NAME = "gameplays.gameplay-waiting-for-user";
+
+  constructor(
+    payload: GameplayWaitingForUserPayload,
+    context: CloudResourceContext
+  ) {
+    super(GameplayWaitingForUser.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => GameplayWaitingForUserPayload)
+  payload: GameplayWaitingForUserPayload;
+}

package/src/v4/events/index.ts

@@ -0,0 +1,84 @@
+export * from "./allocate-game-request";
+export * from "./allocate-game-resource-request";
+export * from "./allocate-machine-request";
+export * from "./aws-reactivate-stream-session-task";
+export * from "./aws-stream-session-reactivation-started";
+export * from "./cloud-machine-auth-ready";
+export * from "./cloud-session-provider-requested";
+export * from "./create-game-resource-request";
+export * from "./create-games-request";
+export * from "./create-machine-resource-batch-request";
+export * from "./create-machine-resource-request";
+export * from "./create-machines-request";
+export * from "./deallocate-machine-request";
+export * from "./game-available";
+export * from "./game-allocated-response";
+export * from "./game-allocation-failed-response";
+export * from "./game-resource-allocated-response";
+export * from "./game-resource-allocation-failed-response";
+export * from "./game-resource-created-response";
+export * from "./game-resource-creation-failed-response";
+export * from "./game-resource-terminated-response";
+export * from "./game-resource-termination-failed-response";
+export * from "./game-terminated-response";
+export * from "./game-termination-failed-response";
+export * from "./game-resource-status-changed";
+export * from "./machine-allocated-response";
+export * from "./machine-allocation-failed-response";
+export * from "./machine-deallocated-response";
+export * from "./machine-deallocation-failed-response";
+export * from "./machine-pool-resizing-task";
+export * from "./machine-resource-batch-creation-failed-response";
+export * from "./machine-resource-batch-termination-failed-response";
+export * from "./machine-resource-created-response";
+export * from "./machine-resource-creation-failed-response";
+export * from "./machine-resource-terminated-response";
+export * from "./machine-resource-updated";
+export * from "./monitor-game-resource-task";
+export * from "./pool-status";
+export * from "./send-pools-to-predictor";
+export * from "./set-pool";
+export * from "./set-pools-state";
+export * from "./swap-cloud-user-completed";
+export * from "./swap-cloud-user-request-failed";
+export * from "./swap-cloud-user-request";
+export * from "./terminate-game-request";
+export * from "./terminate-game-resource-request";
+export * from "./terminate-games-request";
+export * from "./terminate-machine-resource-request";
+export * from "./terminate-machine-resource-batch-request";
+export * from "./terminate-machines-request";
+export * from "./terminate-stale-games";
+export * from "./terminate-stale-machines";
+export * from "./prepare-cloud-machine-auth";
+export * from "./prepare-cloud-machine-auth-failed";
+export * from "./token-required.event";
+export * from "./cloud-machine-auth-ready";
+export * from "./allocate-cloud-session-failed";
+export * from "./allocate-cloud-session-request";
+export * from "./cloud-session-timeout-task";
+export * from "./ludeo-obtained-timeout-task";
+export * from "./terminate-cloud-session-request";
+export * from "./cloud-session-created";
+export * from "./cloud-session-allocated";
+export * from "./terminate-stale-resources-task";
+export * from "./cloud-session-ended";
+export * from "./invalid-game-resource";
+export * from "./game-resource-allocation-timeout-task";
+export * from "./aws-poll-stream-session-task";
+export * from "./game-resource-ready-for-creation";
+export * from "./game-resource-ready-for-creation-failed";
+export * from "./aws-stream-session-active";
+export * from "./cloud-session-optimal-region-selected";
+export * from "./create-ludeos-request";
+export * from "./allocate-ludeo-resource-request";
+export * from "./gameplay-waiting-for-user";
+export * from "./load-ludeo-resource";
+export * from "./ludeo-allocated-response";
+export * from "./ludeo-allocation-failed";
+export * from "./ludeo-resource-allocated-response";
+export * from "./ludeo-resource-allocation-failed";
+export * from "./ludeo-resource-loaded";
+export * from "./ludeo-resource-loading-failed";
+export * from "./swap-to-default-user";
+export * from "./swap-to-default-user-completed";

package/src/v4/events/invalid-game-resource.ts

@@ -0,0 +1,34 @@
+import { IsString, IsUUID } from "class-validator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+import { CloudResourceContext } from "../contexts";
+
+export class InvalidGameResourcePayload {
+  @IsUUID()
+  gamePoolId: string;
+
+  @IsUUID()
+  gameResourceId: string;
+
+  @IsString()
+  errorMessage: string;
+}
+
+export class InvalidGameResource extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resource-monitor.invalid-game-resource";
+
+  constructor(
+    payload: InvalidGameResourcePayload,
+    context: CloudResourceContext
+  ) {
+    super(InvalidGameResource.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => InvalidGameResourcePayload)
+  payload: InvalidGameResourcePayload;
+}

package/src/v4/events/load-ludeo-resource.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 LoadLudeoResourcePayload {
+  @IsUUID()
+  ludeoResourceId: string;
+}
+
+export class LoadLudeoResource extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.load-ludeo-resource";
+
+  constructor(
+    payload: LoadLudeoResourcePayload,
+    context: CloudResourceContext
+  ) {
+    super(LoadLudeoResource.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => LoadLudeoResourcePayload)
+  payload: LoadLudeoResourcePayload;
+}

package/src/v4/events/ludeo-allocated-response.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 LudeoAllocatedResponsePayload {
+  @IsUUID()
+  ludeoResourceId: string;
+}
+
+export class LudeoAllocatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.ludeo-allocated-response";
+
+  constructor(
+    payload: LudeoAllocatedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(LudeoAllocatedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => LudeoAllocatedResponsePayload)
+  payload: LudeoAllocatedResponsePayload;
+}

package/src/v4/events/ludeo-allocation-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 LudeoAllocationFailedPayload {
+  @IsUUID()
+  ludeoResourceId: string;
+}
+
+export class LudeoAllocationFailed extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.ludeo-allocation-failed";
+
+  constructor(
+    payload: LudeoAllocationFailedPayload,
+    context: CloudResourceContext
+  ) {
+    super(LudeoAllocationFailed.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => LudeoAllocationFailedPayload)
+  payload: LudeoAllocationFailedPayload;
+}

package/src/v4/events/ludeo-obtained-timeout-task.ts

@@ -0,0 +1,23 @@
+import { IsUUID } from "class-validator";
+import { LudeoEvent } from "../../infra/ludeo-event";
+import { ValidateNestedType } from "../../decorators/validate-nested-type.decorator";
+
+export class LudeoObtainedTimeoutTaskPayload {
+  @IsUUID()
+  cloudSessionId: string;
+}
+
+export class LudeoObtainedTimeoutTaskEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-sessions.ludeo-obtained-timeout-task";
+
+  constructor(payload: LudeoObtainedTimeoutTaskPayload, context: never) {
+    super(LudeoObtainedTimeoutTaskEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  context: never;
+
+  @ValidateNestedType(() => LudeoObtainedTimeoutTaskPayload)
+  payload: LudeoObtainedTimeoutTaskPayload;
+}

package/src/v4/events/ludeo-resource-allocated-response.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 LudeoResourceAllocatedResponsePayload {
+  @IsUUID()
+  ludeoResourceId: string;
+}
+
+export class LudeoResourceAllocatedResponse extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-resources.ludeo-resource-allocated-response";
+
+  constructor(
+    payload: LudeoResourceAllocatedResponsePayload,
+    context: CloudResourceContext
+  ) {
+    super(LudeoResourceAllocatedResponse.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => LudeoResourceAllocatedResponsePayload)
+  payload: LudeoResourceAllocatedResponsePayload;
+}