js-dos 7.2.1 → 7.2.6

package/examples/digger/index.html

@@ -24,7 +24,11 @@
         let bundleUrl = "https://cdn.dos.zone/original/2X/2/24b00b14f118580763440ecaddcc948f8cb94f14.jsdos"; // digger
             // bundleUrl = "https://cdn.dos.zone/original/2X/6/6a2bfa87c031c2a11ab212758a5d914f7c112eeb.jsdos"; // dagnerous dave 2
             // bundleUrl = "https://cdn.dos.zone/original/2X/1/1b063b2520052ebb504184667ac95e72423331de.jsdos"; // lost vikings
-            bundleUrl = "bundle.jsdos";
+            // bundleUrl = "doom.jsdos";
+            // bundleUrl = "wolf.jsdos";
+            // bundleUrl = "heroes2.jsdos";
+            // bundleUrl = "https://doszone-uploads.s3.dualstack.eu-central-1.amazonaws.com/original/2X/6/60b165c86771eadf24cb2f81aef4656b85d167a6.jsdos";
+            // bundleUrl = "doom_coop.jsdos";
         let clientId = null;
         emulators.pathPrefix = "/dist/";
         Dos(document.getElementById("jsdos"), {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "js-dos",
-    "version": "7.2.1",
+    "version": "7.2.6",
     "description": "Easiest API to run dos programs in browser",
     "main": "dist/js-dos.js",
     "types": "dist/types/src/player.d.ts",
@@ -21,7 +21,7 @@
         "dosbox"
     ],
     "author": "Alexander Guryanov (aka caiiiycuk)",
-    "license": "ISC",
+    "license": "GPL-2.0",
     "bugs": {
         "url": "https://github.com/caiiiycuk/js-dos/issues"
     },
@@ -48,8 +48,8 @@
         "browserify": "^17.0.0",
         "core-js": "^3.17.1",
         "del": "^5.1.0",
-        "emulators": "^0.72.0",
-        "emulators-ui": "^0.72.2",
+        "emulators": "^0.72.1",
+        "emulators-ui": "^0.72.8",
         "eslint": "^7.32.0",
         "eslint-config-google": "^0.14.0",
         "gulp": "^4.0.2",
@@ -66,5 +66,8 @@
         "typescript": "^4.4.4",
         "vinyl-buffer": "^1.0.1",
         "vinyl-source-stream": "^2.0.0"
+    },
+    "dependencies": {
+        "nanoid": "^3.1.30"
     }
 }

package/v7-services/.env

@@ -0,0 +1,6 @@
+# Learn more about about the credentials needed
+# to deploy your app https://github.com/serverless/components#credentials
+
+# AWS:
+# AWS_ACCESS_KEY_ID=<your access key>
+# AWS_SECRET_ACCESS_KEY=<your secret access key>

package/v7-services/ok.yaml

@@ -0,0 +1,24 @@
+service: jsdos-ok
+
+package:
+  exclude:
+    - 'node_modules/**'
+
+provider:
+  name: aws
+  runtime: nodejs14.x
+  memorySize: 128
+  versionFunctions: false
+
+functions:
+  ok:
+    handler: src/ok.ok
+    name: jsdos-ok
+    events:
+      - http:
+          path: /ok
+          method: get
+          cors: true
+
+plugins:
+  - serverless-plugin-typescript

package/v7-services/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "js-dos-v7-services",
+  "description": "",
+  "version": "0.1.0",
+  "license": "GPL-2.0",
+  "dependencies": {
+    "nanoid": "^3.1.30"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "^8.10.88",
+    "@types/node": "^14.6.4",
+    "aws-sdk": "^2.1048.0",
+    "serverless": "^2.69.1",
+    "serverless-plugin-typescript": "^2.1.0",
+    "typescript": "^4.5.4"
+  }
+}

package/v7-services/redeploy-ok.sh

@@ -0,0 +1,25 @@
+#!/bin/sh
+
+set -ex
+
+yarn run sls deploy -c ok.yaml --verbose --region us-east-1 
+yarn run sls deploy -c ok.yaml --verbose --region us-east-2
+yarn run sls deploy -c ok.yaml --verbose --region us-west-1
+yarn run sls deploy -c ok.yaml --verbose --region us-west-2
+yarn run sls deploy -c ok.yaml --verbose --region eu-central-1
+yarn run sls deploy -c ok.yaml --verbose --region eu-west-1
+yarn run sls deploy -c ok.yaml --verbose --region eu-west-2
+yarn run sls deploy -c ok.yaml --verbose --region eu-south-1
+yarn run sls deploy -c ok.yaml --verbose --region eu-west-3
+yarn run sls deploy -c ok.yaml --verbose --region eu-north-1
+yarn run sls deploy -c ok.yaml --verbose --region ap-east-1
+yarn run sls deploy -c ok.yaml --verbose --region ap-south-1
+yarn run sls deploy -c ok.yaml --verbose --region ap-northeast-3
+yarn run sls deploy -c ok.yaml --verbose --region ap-northeast-2
+yarn run sls deploy -c ok.yaml --verbose --region ap-southeast-1
+yarn run sls deploy -c ok.yaml --verbose --region ap-southeast-2
+yarn run sls deploy -c ok.yaml --verbose --region ap-northeast-1
+yarn run sls deploy -c ok.yaml --verbose --region ca-central-1
+yarn run sls deploy -c ok.yaml --verbose --region me-south-1
+yarn run sls deploy -c ok.yaml --verbose --region sa-east-1
+yarn run sls deploy -c ok.yaml --verbose --region af-south-1

package/v7-services/serverless.yml

@@ -0,0 +1,140 @@
+org: caiiiycuk
+app: jsdos-backend
+service: jsdos-v7
+
+provider:
+  name: aws
+  runtime: nodejs14.x
+  region: eu-central-1
+  memorySize: 256
+  versionFunctions: false
+  environment:
+    NETWORKING_TABLE: "v2_r1_dznetworking"
+    PUT_CURL: "jjs-putCurl"
+    RUN_INSTANCE: "jjs-runInstanceV2"
+  iamRoleStatements:
+    - Effect: Allow
+      Action:
+        - s3:ListBucket
+      Resource:
+        - "arn:aws:s3:::doszone-uploads"
+    - Effect: Allow
+      Action:
+        - s3:Get*
+        - s3:Put*
+      Resource:
+        - "arn:aws:s3:::doszone-uploads/*"
+    - Effect: Allow
+      Action:
+        - lambda:InvokeFunction
+      Resource:
+        - "arn:aws:lambda:${opt:region, self:provider.region}:*:function:${self:provider.environment.PUT_CURL}"
+        - "arn:aws:lambda:${opt:region, self:provider.region}:*:function:${self:provider.environment.RUN_INSTANCE}"
+    - Effect: Allow
+      Action:
+        - dynamodb:Query
+        - dynamodb:Scan
+        - dynamodb:GetItem
+        - dynamodb:PutItem
+        - dynamodb:UpdateItem
+        - dynamodb:DeleteItem
+      Resource:
+        - "arn:aws:dynamodb:${opt:region, self:provider.region}:*:table/${self:provider.environment.NETWORKING_TABLE}"
+
+functions:
+  getTokenCost: 
+    handler: src/networking/get-token-cost.getTokenCost
+    name: jsdos-getTokenCost
+    events:
+      - http:
+          path: /token/cost/get
+          method: get
+          cors: true
+  getFreeToken:
+    handler: src/networking/get-free-token.getFreeToken
+    name: jsdos-getFreeToken
+    events:
+      - http:
+          path: /token/free/get
+          method: get
+          cors: true
+  getTokenInfo:
+    handler: src/networking/get-token-info.getTokenInfo
+    name: jsdos-getTokenInfo
+    events:
+      - http:
+          path: /token/info/get
+          method: get
+          cors: true
+  startIpx:
+    handler: src/networking/ipx/start-ipx.startIpx
+    name: jsdos-startIpx
+    events:
+      - http:
+          path: /token/ipx/start
+          method: get
+          cors: true
+  putIpxIp:
+    handler: src/networking/ipx/put-ipx-ip.putIpxIp
+    name: jsdos-putIpxIp
+    events:
+      - http:
+          path: /token/ipx/ip/put
+          method: put
+          cors: true
+  stopIpx:
+    handler: src/networking/ipx/stop-ipx.stopIpx
+    name: jsdos-stopIpx
+    events:
+      - http:
+          path: /token/ipx/stop
+          method: post
+          cors: true
+  personalPut:
+    handler: src/personal-put.personalPut
+    name: jsdos-personalPut
+    events:
+      - http:
+          path: /personal/put
+          method: post
+          cors: true
+  personalAcl:
+    handler: src/personal-acl.personalAcl
+    name: jsdos-personalAcl
+    events:
+      - http:
+          path: /personal/acl
+          method: post
+          cors: true
+
+resources:
+  Resources:
+    dznetworking:
+      Type: 'AWS::DynamoDB::Table'
+      DeletionPolicy: Retain
+      Properties:
+        AttributeDefinitions:
+          -
+            AttributeName: key
+            AttributeType: S
+          -
+            AttributeName: day
+            AttributeType: N
+        KeySchema:
+          -
+            AttributeName: key
+            KeyType: HASH
+        GlobalSecondaryIndexes:
+          -
+            IndexName: day
+            KeySchema:
+            -
+              AttributeName: day
+              KeyType: HASH
+            Projection:
+              ProjectionType: ALL
+        TableName: ${self:provider.environment.NETWORKING_TABLE}
+        BillingMode: PAY_PER_REQUEST
+
+plugins:
+  - serverless-plugin-typescript

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

@@ -0,0 +1,5 @@
+export function getDayOrigin() {
+    const date = new Date();
+    return (Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()) -
+        Date.UTC(date.getFullYear(), 0, 0)) / 24 / 60 / 60 / 1000 + date.getFullYear() * 366;
+}

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

@@ -0,0 +1,33 @@
+import { error, badRequest, success } from "../responses";
+import { getDayOrigin } from "./day";
+import { freeTierSoftLimit, freeTierHardLimit } from "./limits";
+import { createFreeToken, getFreeTierHardCount, getFreeTierSoftCount } from "./token";
+
+export const getFreeToken = async (event: any) => {
+    const namespace = event.queryStringParameters?.namespace;
+    const id = event.queryStringParameters?.id;
+    const region = event.queryStringParameters?.region;
+    const day = getDayOrigin();
+
+    if (!namespace || !id || !region) {
+        return badRequest();
+    }
+
+    const softCount = await getFreeTierSoftCount(namespace, id, day);
+    if (softCount >= freeTierSoftLimit) {
+        return error("free-soft-limit");
+    }
+
+    const hardCount = await getFreeTierHardCount(day);
+    if (hardCount >= freeTierHardLimit) {
+        return error("free-hard-limit");
+    }
+
+    try {
+        return success({
+            token: await createFreeToken(namespace, id, day, region),
+        });
+    } catch (e) {
+        return error(e.message);
+    }
+};

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

@@ -0,0 +1,31 @@
+import { error, badRequest, success } from "../responses";
+import { getDayOrigin } from "./day";
+import { freeTierSoftLimit, freeTierSec, freeTierHardLimit } from "./limits";
+import { getFreeTierHardCount, getFreeTierSoftCount } from "./token";
+
+export const getTokenCost = async (event: any) => {
+    const namespace = event.queryStringParameters?.namespace;
+    const id = event.queryStringParameters?.id;
+    const durationSec = Number.parseInt(event.queryStringParameters?.durationSec);
+    const day = getDayOrigin();
+
+    if (!namespace || !id || !durationSec || isNaN(durationSec)) {
+        return badRequest();
+    }
+
+    if (freeTierSec !== durationSec) {
+        return error("30-min-required");
+    }
+
+    if (await getFreeTierSoftCount(namespace, id, day) >= freeTierSoftLimit) {
+        return error("free-soft-limit");
+    }
+
+    if (await getFreeTierHardCount(day) >= freeTierHardLimit) {
+        return error("free-hard-limit");
+    }
+
+    return success({
+        cost: 0,
+    });
+};

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

@@ -0,0 +1,16 @@
+import { badRequest, error, success } from "../responses";
+import { getToken } from "./token";
+
+export const getTokenInfo = async (event: any) => {
+    const token = event.queryStringParameters?.token;
+
+    if (!token) {
+        return badRequest();
+    }
+
+    try {
+        return success(await getToken(token));
+    } catch (e) {
+        return error(e.message);
+    }
+};

package/v7-services/src/networking/ipx/put-ipx-ip.ts

@@ -0,0 +1,20 @@
+import { error, badRequest, success } from "../../responses";
+import { putIp } from "../token";
+
+export const putIpxIp = async (event: any) => {
+    const token = event.queryStringParameters?.token;
+    const arn = event.queryStringParameters?.arn;
+    const ip = event.queryStringParameters.ip;
+
+    if (!token || !arn || !ip) {
+        return badRequest();
+    }
+
+    try {
+        await putIp(token, arn, ip, "ipx");
+        return success({});
+    } catch (e) {
+        console.error("Can't update ipx ip", e);
+        return error(e.message);
+    }
+};

package/v7-services/src/networking/ipx/start-ipx.ts

@@ -0,0 +1,16 @@
+import { error, badRequest, success } from "../../responses";
+import { newTask } from "../token";
+
+export const startIpx = async (event: any) => {
+    const token = event.queryStringParameters?.token;
+    if (!token) {
+        return badRequest();
+    }
+
+    try {
+        return success({ arn: await newTask(token, "ipx") });
+    } catch (e) {
+        console.error("Can't start ipx-server", e);
+        return error(e.message);
+    }
+};

package/v7-services/src/networking/ipx/stop-ipx.ts

@@ -0,0 +1,19 @@
+import { error, badRequest, success } from "../../responses";
+import { stopTask } from "../token";
+
+export const stopIpx = async (event: any) => {
+    const token = event.queryStringParameters?.token;
+    const arn = event.queryStringParameters?.arn;
+
+    if (!token || !arn) {
+        return badRequest();
+    }
+
+    try {
+        await stopTask(token, arn, "ipx");
+        return success({});
+    } catch (e) {
+        console.error("Can't update ipx ip", e);
+        return error(e.message);
+    }
+};

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

@@ -0,0 +1,3 @@
+export const freeTierSoftLimit = 24;
+export const freeTierHardLimit = 256;
+export const freeTierSec = 30 * 60; // 30 min

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

@@ -0,0 +1,238 @@
+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

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