import { v4 } from 'uuid';
import { SQSClient, SendMessageBatchCommand } from "@aws-sdk/client-sqs";

export class SchedulingService {
    sqsClient: SQSClient;

    constructor(private queueUrl: string, private batchSize: number) {
        this.sqsClient = new SQSClient();
    }

    async dispatch(taskPrefix: string, delayInterval: number): Promise<void> {
        const messages: SendMessageBatchRequestEntry[] = [];

        for (let i = 1; i <= this.batchSize; i++) {
            const step = i * this.batchSize;
            const id = v4();

            message.push({
                Id: `${taskPrefix}-${id}`,
                MessageBody: JSON.stringify({
                    StepId: step
                }),
                DelaySeconds: step * delayInterval
            });
        }

        const command = new SendMessageBatchCommand({
            QueueUrl: this.queueUrl,
            Entries: messages
        });
        await this.sqsClient.send(command)
    }

}

import { SchedulingService } from '.../scheduling.service';

// Variables passed by environment
const queueUrl = ...;
const batchSize = ...;
const taskPrefix = ...;

const scheduler = new SchedulingService(queueUrl, batchSize);

export async function schedulingHandler(_event: any) {

    await scheduler.dispatch(taskPrefix, 6);
}

import { DynamoDBClient, UpdateItemCommand } from "@aws-sdk/client-dynamodb";

export class SemaphoreService {
    dynamoClient: DynamoDBClient;

    constructor(private tableName: string, private keyName: string) {
        this.dynamoClient = new DynamoDBClient({});
    }

    async acquire(): Promise<boolean> {
        try {
            await this.dispathCommand(true);
        } catch (error) {
            return Promise.resolve(false);
        }

        return Promise.resolve(true);
    }

    async release(): Promise<boolean> {
        try {
            await this.dispathCommand(false);
        } catch (error) {
            return Promise.resolve(false);
        }

        return Promise.resolve(true);
    }

    private async dispathCommand(requestLock: boolean): Promise<any> {
        const cmd = new UpdateItemCommand({
            TableName: this.tableName,
            Key: {
                PK: { S: this.keyName }
            },
            UpdateExpression: 'SET Value = :NewValue',
            ConditionExpression: 'Value = :OldValue'
        });

        if (requestLock) {
            cmd.input.ExpressionAttributeValues = {
                ':NewValue': { N: '1' },
                ':OldValue': { N: '0' },
            }
        } else {
            cmd.input.ExpressionAttributeValues = {
                ':NewValue': { N: '0' },
                ':OldValue': { N: '1' },
            }
        }

        return await this.dynamoClient.send(cmd);
    }
}

import { SemaphoreService } from '.../semaphore.service';

// Variables passed by environment
const tableName = ...;
const semaphoreName = ...;

const semaphore = new SemaphoreService(tableName, semaphoreName);

export async function taskHandler(_event: any) {
    const acquired = await semaphore.acquire();
    if (!acquired) {
        return;
    }

    // Process with the task
    ...
}

def lambda_handler(event, context):

    try:
        # Check if the SQS queue has any player waiting
        resp = sqs_client.receive_message(
            QueueUrl=...,
            ...
        )

        # Delete message from SQS queue
        sqs_client.delete_message(
            QueueUrl=...,
            ReceiptHandle=...
        )

        # Send existing server connection to the requesting player
        connection_info = resp['Messages'][0]['Body']
        ...
        ...

    except:
        print('No player waiting')

    # Request a server from GameLift
    connection_info = ...

    # Send server information to the SQS queue
    resp = sqs_client.send_message(
        QueueUrl=...,
        MessageBody=(
            connection_info
        )
    )

    # Send new server connection to the requesting player
    ...

import * as cdk from 'aws-cdk-lib';
import * as globalaccelerator from '@aws-cdk/aws-globalaccelerator';
import * as sqs from '@aws-cdk/aws-sqs';

export class MyStack extends cdk.Stack {
  constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Create a new Global Accelerator
    const accelerator = new globalaccelerator.GlobalAccelerator(this, 'Accelerator', {
      acceleratorType: globalaccelerator.AcceleratorType.STATIC,
      enabled: true,
      regions: [globalaccelerator.Regions.US_EAST_1, globalaccelerator.Regions.US_WEST_2]
    });

    // Create an SQS queue
    const queue = new sqs.Queue(this, 'Queue', {
      visibilityTimeout: cdk.Duration.seconds(300)
    });

    // Create an accelerator endpoint for the queue
    const endpoint = new globalaccelerator.AcceleratorEndpoint(this, 'Endpoint', {
      accelerator,
      port: 80,
      protocol: globalaccelerator.Protocol.TCP,
      resource: queue
    });

    // Create a listener for the endpoint
    new globalaccelerator.Listener(this, 'Listener', {
      accelerator,
      port: 80,
      protocol: globalaccelerator.Protocol.TCP,
      endpointGroups: [{
        endpoints: [endpoint]
      }]
    });
  }
}