js-dos 7.2.7 → 7.3.0

package/v7-services/src/networking/token.ts

@@ -1,238 +0,0 @@
-import * as AWS from "aws-sdk";
-import { freeTierHardLimit, freeTierSec, freeTierSoftLimit } from "./limits";
-import { customAlphabet } from "nanoid/async";
-
-const dynamoDb = new AWS.DynamoDB.DocumentClient();
-const NETWORKING_TABLE = process.env.NETWORKING_TABLE as string;
-
-const lambda = new AWS.Lambda();
-const RunInstanceLambda = process.env.RUN_INSTANCE as string;
-
-const nanoid = customAlphabet("0123456789abcdefghijklmnopqrstuvwxyz", 6);
-
-interface Token {
-    day: number,
-    region: string,
-    endTime: number,
-    ttlSec: number,
-}
-
-export type TaskType = "ipx";
-
-export async function getFreeTierSoftCount(namespace: string, id: string, day: number): Promise<number> {
-    const freeTierSoftKey = getFreeTierSoftKey(namespace, id, day);
-    const response = await dynamoDb.get({
-        TableName: NETWORKING_TABLE,
-        Key: {
-            key: freeTierSoftKey,
-        },
-    }).promise();
-
-    return response.Item?.count || 0;
-}
-
-export async function getFreeTierHardCount(day: number): Promise<number> {
-    const freeTierHardKey = getFreeTierHardKey(day);
-    const response = await dynamoDb.get({
-        TableName: NETWORKING_TABLE,
-        Key: {
-            key: freeTierHardKey,
-        },
-    }).promise();
-
-    return response.Item?.count || 0;
-}
-
-export async function createFreeToken(namespace: string, id: string, day: number, region: string): Promise<string> {
-    const freeTierSoftKey = getFreeTierSoftKey(namespace, id, day);
-    const freeTierHardKey = getFreeTierHardKey(day);
-
-    const inc = async (key: string, inc: number) => {
-        const updateParams: AWS.DynamoDB.DocumentClient.UpdateItemInput = {
-            TableName: NETWORKING_TABLE,
-            Key: {
-                key,
-            },
-            UpdateExpression: "ADD #count :inc",
-            ExpressionAttributeNames: {
-                "#count": "count",
-            },
-            ExpressionAttributeValues: {
-                ":inc": inc,
-            },
-            ReturnValues: "ALL_NEW",
-        };
-
-        const response = await dynamoDb.update(updateParams).promise();
-        if (typeof response.Attributes?.count !== "number") {
-            console.error("Can't get updated count value for key " + key, response);
-            throw new Error("Can't get updated count value for key " + key);
-        }
-
-        return response.Attributes?.count as number;
-    };
-
-    const [softCount, hardCount] = await Promise.all([inc(freeTierSoftKey, 1), inc(freeTierHardKey, 1)]);
-
-    try {
-        if (softCount > freeTierSoftLimit) {
-            throw new Error("free-soft-limit");
-        }
-
-        if (hardCount > freeTierHardLimit) {
-            throw new Error("free-hard-limit");
-        }
-    } catch (e: any) {
-        // rollback
-        await Promise.all([inc(freeTierSoftKey, -1), inc(freeTierHardKey, -1)]);
-        throw e;
-    }
-
-    return createToken(namespace, id, day, region, freeTierSec);
-}
-
-export async function getToken(token: string): Promise<Token> {
-    const item = (await dynamoDb.get({
-        TableName: NETWORKING_TABLE,
-        Key: {
-            key: getTokenKey(token),
-        },
-    }).promise()).Item as Token | undefined;
-
-    if (item === undefined) {
-        throw new Error("not-found");
-    }
-
-    item.ttlSec = Math.round((item.endTime - new Date().getTime()) / 1000);
-
-    return item;
-}
-
-export async function createToken(namespace: string, id: string, day: number,
-                                  region: string, durationSec: number): Promise<string> {
-    let token: string | null = null;
-    while (token === null) {
-        token = await nanoid();
-
-        const createParams: AWS.DynamoDB.DocumentClient.PutItemInput = {
-            TableName: NETWORKING_TABLE,
-            Item: {
-                "key": getTokenKey(token),
-                namespace,
-                id,
-                day,
-                region,
-                durationSec,
-                "createdAt": new Date().getTime(),
-                "endTime": new Date().getTime() + durationSec * 1000,
-            },
-            ConditionExpression: "attribute_not_exists(#key)",
-            ExpressionAttributeNames: {
-                "#key": "key",
-            },
-        };
-
-        try {
-            await dynamoDb.put(createParams).promise();
-        } catch (e) {
-            console.error(e);
-            token = null;
-        }
-    }
-
-    return token;
-}
-
-export async function newTask(tokenId: string, task: TaskType) {
-    const token = await getToken(tokenId);
-
-    if (token.ttlSec < 60) { // 1min to start container
-        throw new Error("ended");
-    }
-
-    const result = await lambda.invoke({
-        FunctionName: RunInstanceLambda,
-        Payload: JSON.stringify({
-            token: tokenId,
-            region: token.region,
-            task,
-        }),
-    }).promise();
-
-    if (!result.Payload) {
-        throw new Error("unable-to-start-task");
-    }
-
-    const payload = JSON.parse(JSON.parse(result.Payload as string).body);
-
-    if (payload.success === false) {
-        throw new Error(payload.errorCode);
-    }
-
-    const arn = payload.arn;
-
-    if (arn === undefined) {
-        throw new Error("ARN missed in runInstanceV2 response");
-    }
-
-    const updateParams: AWS.DynamoDB.DocumentClient.UpdateItemInput = {
-        TableName: NETWORKING_TABLE,
-        Key: {
-            key: getTokenKey(tokenId),
-        },
-        UpdateExpression: `SET ${task}Arn = :arn`,
-        ExpressionAttributeValues: {
-            ":arn": arn,
-        },
-    };
-
-    await dynamoDb.update(updateParams).promise();
-
-    return arn;
-}
-
-export async function putIp(token: string, arn: string, ip: string, task: TaskType) {
-    const updateParams: AWS.DynamoDB.DocumentClient.UpdateItemInput = {
-        TableName: NETWORKING_TABLE,
-        Key: {
-            key: getTokenKey(token),
-        },
-        UpdateExpression: `SET ${task}Ip = :ip`,
-        ConditionExpression: `${task}Arn = :arn`,
-        ExpressionAttributeValues: {
-            ":arn": arn,
-            ":ip": ip,
-        },
-    };
-
-    await dynamoDb.update(updateParams).promise();
-}
-
-export async function stopTask(token: string, arn: string, task: TaskType) {
-    const updateParams: AWS.DynamoDB.DocumentClient.UpdateItemInput = {
-        TableName: NETWORKING_TABLE,
-        Key: {
-            key: getTokenKey(token),
-        },
-        UpdateExpression: `REMOVE ${task}Arn, ${task}Ip`,
-        ConditionExpression: `${task}Arn = :arn`,
-        ExpressionAttributeValues: {
-            ":arn": arn,
-        },
-    };
-
-    await dynamoDb.update(updateParams).promise();
-}
-
-
-function getFreeTierSoftKey(namespace: string, id: string, day: number) {
-    return "free-soft " + day + " " + id + "@" + namespace;
-}
-
-function getFreeTierHardKey(day: number) {
-    return "free-hard " + day;
-}
-
-function getTokenKey(token: string) {
-    return "token " + token;
-}

package/v7-services/src/ok.ts

@@ -1,7 +0,0 @@
-import { Handler } from "aws-lambda";
-
-import { success } from "./responses";
-
-export const ok: Handler = async (event: any) => {
-    return success({});
-};

package/v7-services/src/personal-acl.ts

@@ -1,33 +0,0 @@
-import { Handler } from "aws-lambda";
-
-import { badRequest, noSession, success } from "./responses";
-
-import * as AWS from "aws-sdk";
-import { validateUser } from "./user";
-import { getPersonalBundleKey, uploadsS3Bucket } from "./personal";
-
-const s3 = new AWS.S3();
-
-export const personalAcl: Handler = async (event: any) => {
-    const namespace = event.queryStringParameters.namespace;
-    const id = event.queryStringParameters.id;
-    const bundleUrl = event.queryStringParameters.bundleUrl;
-
-    if (!bundleUrl || bundleUrl.length === 0) {
-        return badRequest();
-    }
-
-    if (!validateUser(namespace, id)) {
-        return noSession();
-    }
-
-    const personalKey = getPersonalBundleKey(namespace, id, bundleUrl);
-
-    await s3.putObjectAcl({
-        Bucket: uploadsS3Bucket,
-        Key: personalKey,
-        ACL: "public-read",
-    }).promise();
-
-    return success({});
-};

package/v7-services/src/personal-put.ts

@@ -1,35 +0,0 @@
-import { Handler } from "aws-lambda";
-
-import { badRequest, noSession, success } from "./responses";
-import { validateUser } from "./user";
-
-import * as AWS from "aws-sdk";
-import { getPersonalBundleUrl } from "./personal";
-
-const PutCurlLambda = process.env.PUT_CURL as string;
-const lambda = new AWS.Lambda();
-
-export const personalPut: Handler = async (event: any) => {
-    const namespace = event.queryStringParameters.namespace;
-    const id = event.queryStringParameters.id;
-    const bundleUrl = event.queryStringParameters.bundleUrl;
-
-    if (!bundleUrl || bundleUrl.length === 0) {
-        return badRequest();
-    }
-
-    if (!validateUser(namespace, id)) {
-        return noSession();
-    }
-
-    const personalUrl = getPersonalBundleUrl(namespace, id, bundleUrl);
-
-    const result = await lambda.invoke({
-        FunctionName: PutCurlLambda,
-        Payload: JSON.stringify({
-            bundleUrl: personalUrl,
-        }),
-    }).promise();
-
-    return success({ payload: result.Payload });
-};

package/v7-services/src/personal.ts

@@ -1,18 +0,0 @@
-export const uploadsS3Bucket = "doszone-uploads";
-
-const uploadsS3Url = "https://doszone-uploads.s3.dualstack.eu-central-1.amazonaws.com";
-
-export function getPersonalBundleKey(namespace: string, id: string, bundleUrl: string): string {
-    const index = bundleUrl.lastIndexOf("/");
-    const basename = bundleUrl.substr(index + 1);
-    if (namespace === "doszone") {
-        return "personal/" + id + "/" + basename;
-    } else {
-        return "personal-v2/" + namespace + "/" + id + "/" + basename;
-    }
-}
-
-export function getPersonalBundleUrl(namespace: string, id: string, bundleUrl: string): string {
-    const personalBundleKey = getPersonalBundleKey(namespace, id, bundleUrl);
-    return uploadsS3Url + "/" + personalBundleKey;
-}

package/v7-services/src/responses.ts

@@ -1,28 +0,0 @@
-export function success(body: any) {
-    return response200(body, true);
-}
-
-export function error(errorCode: string) {
-    return response200({ errorCode }, false);
-}
-
-export function badRequest() {
-    return error("error_bad_request");
-}
-
-export function noSession() {
-    return error("error_no_session");
-}
-
-function response200(body: any, success: boolean) {
-    body.success = success;
-
-    return {
-        statusCode: 200,
-        headers: {
-            "Access-Control-Allow-Origin": "*",
-            "Access-Control-Allow-Credentials": true,
-        },
-        body: JSON.stringify(body, null, 2),
-    };
-}

package/v7-services/src/user.ts

@@ -1,3 +0,0 @@
-export function validateUser(namespace: string, id: string): boolean {
-    return typeof namespace === "string" && typeof id === "string" && namespace.length > 0 && id.length > 0;
-}