socket-function 0.5.0 → 0.6.0

package/src/socketServer.ts

@@ -0,0 +1,140 @@
+import https from "https";
+import http from "http";
+import net from "net";
+import tls from "tls";
+import * as ws from "ws";
+import { performLocalCall } from "./callManager";
+import { CallerContext, CallType, NetworkLocation } from "../SocketFunctionTypes";
+import { CallFactory, callFactoryFromWS } from "./CallFactory";
+import { registerNodeClient } from "./nodeCache";
+import { getCertKeyPair, getNodeId, getNodeIdRaw } from "./nodeAuthentication";
+import debugbreak from "debugbreak";
+import { cache } from "./caching";
+import { getNodeIdFromRequest, httpCallHandler } from "./callHTTPHandler";
+
+// TODO: Support conditional peer certificate requests, as it the certificate prompt
+//  seems suspicious in the browser (the user can just click cancel though).
+
+export type SocketServerConfig = (
+    {
+        port: number;
+        // public sets ip to "0.0.0.0", otherwise it defaults to "127.0.0.1", which
+        //  causes the server to only accept local connections.
+        public?: boolean;
+        ip?: string;
+    } & (
+        https.ServerOptions
+    )
+);
+
+export async function startSocketServer(
+    config: SocketServerConfig
+) {
+    let isSecure = "cert" in config || "key" in config || "pfx" in config;
+    if (!isSecure) {
+        let { key, cert } = getCertKeyPair();
+        config.key = key;
+        config.cert = cert;
+    }
+
+    // TODO: Only allow unauthorized for ip certificates, and then for domains use the domain as the nodeId,
+    //  so it is easy to read, and consistent.
+    let httpsServer = https.createServer({
+        ...config,
+        rejectUnauthorized: false,
+        requestCert: true,
+    });
+
+
+    httpsServer.on("request", httpCallHandler);
+
+    const webSocketServer = new ws.Server({
+        noServer: true,
+    });
+    httpsServer.on("upgrade", (request, socket, upgradeHead) => {
+        webSocketServer.handleUpgrade(request, socket, upgradeHead, async (ws) => {
+            // NOTE: For the browser, the request will likely have a nodeId, from making an HTTP request.
+            //  We would prefer peer certificates, so this isn't the default (in getNodeId), but it will
+            //  likely be used most of the time.
+            let requestNodeId = getNodeIdFromRequest(request);
+            Object.assign(ws, { nodeId: requestNodeId });
+
+            let clientCallFactory = await callFactoryFromWS(ws);
+            registerNodeClient(clientCallFactory);
+        });
+    });
+
+    let httpServer = http.createServer({}, async function (req, res) {
+        let url = new URL("http://" + req.headers.host + req.url);
+        url.protocol = "https:";
+        //url.hostname = opts.hostname;
+        url.hostname = req.headers.host || "";
+        res.writeHead(301, { Location: url + "" });
+        res.end();
+    });
+
+    httpServer.listen(0, "127.0.0.1");
+    httpsServer.listen(0, "127.0.0.1");
+
+    // TODO: We should really add error handling here, but... we should always be able to listen
+    //  on ANY port on localhost, as why couldn't we?
+    let httpServerReady = new Promise(resolve => httpServer.once("listening", resolve));
+    let httpsServerReady = new Promise(resolve => httpsServer.once("listening", resolve));
+    await httpServerReady;
+    await httpsServerReady;
+
+    let httpAddress = httpServer.address() as net.AddressInfo;
+    let httpsAddress = httpsServer.address() as net.AddressInfo;
+
+
+    let realServer = net.createServer(socket => {
+        // NOTE: ONCE is used, so we only look at the first buffer, and then after that
+        //  we pipe. This should be very efficient, as pipe has insane throughput
+        //  (100s of MB/s, easily, even on a terrible machine).
+        socket.once("data", buffer => {
+            // All HTTPS requests start with 22, and no HTTP requests start with 22,
+            //  so we just need to read the first byte.
+            let byte = buffer[0];
+            let isHTTPS = byte === 22;
+            let address = httpAddress;
+            if (isHTTPS) {
+                address = httpsAddress;
+            }
+            let baseSocket = net.connect(address.port);
+
+            baseSocket.write(buffer);
+            socket.pipe(baseSocket);
+            baseSocket.pipe(socket);
+
+            baseSocket.on("error", (e) => {
+                console.error(`Base socket error, ${e.stack}`);
+            });
+        });
+        socket.on("error", (e) => {
+            console.error(`Exposed socket error, ${e.stack}`);
+        });
+    });
+
+
+    let listenPromise = new Promise<void>((resolve, error) => {
+        realServer.on("listening", () => {
+            resolve();
+        });
+        realServer.on("error", e => {
+            error(e);
+        });
+    });
+
+
+    let host = config.ip ?? "127.0.0.1";
+    if (config.public) {
+        host = "0.0.0.0";
+    }
+
+    console.log(`Trying to listening on ${host}:${config.port}`);
+    realServer.listen(config.port, host);
+
+    await listenPromise;
+
+    console.log(`Started Listening on ${host}:${config.port}`);
+}

package/{storagePath.ts → src/storagePath.ts}

@@ -2,9 +2,9 @@ import os from "os";
 import fs from "fs";
 import { lazy } from "./caching";
 
-export const getAppFolder = lazy(() => {    
+export const getAppFolder = lazy(() => {
     const path = os.homedir() + "/socket-function/";
-    if(!fs.existsSync(path)) {
+    if (!fs.existsSync(path)) {
         fs.mkdirSync(path);
     }
     return path;

package/test/client.css

@@ -0,0 +1,3 @@
+body {
+    background: orange;
+}

package/test/client.ts

@@ -0,0 +1,42 @@
+// https://letx.ca:2542/?classGuid=RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d&functionName=requireHTML&args=[%22./test/test%22]
+
+//import typescript from "typescript";
+
+import debugbreak from "debugbreak";
+import { setFlag } from "../require/compileFlags";
+import { SocketFunction } from "../SocketFunction";
+import { Test } from "./shared";
+
+import "./client.css";
+import { isNode } from "../src/misc";
+
+module.allowclient = true;
+
+//console.log(typeof typescript);
+
+//setFlag(require, "typescript", "allowclient", true);
+
+
+void main();
+
+async function main() {
+    if (isNode()) return;
+
+    SocketFunction.expose(Test);
+
+    console.log("cool");
+
+    const port = 2542;
+
+    let serverId = await SocketFunction.connect({ port, address: "letx.ca" });
+    let test = await Test.nodes[serverId].add(1, 2);
+    console.log(`${test}=${1 + 2}`);
+
+    // while (true) {
+    //     let test = await TestClass.nodes[serverId].add(1, 2);
+    //     console.log(`${test}=${1 + 2}`);
+    //     await new Promise(resolve => setTimeout(resolve, 1000));
+    // }
+
+    await Test.nodes[serverId].callMe();
+}

package/test/server.ts

@@ -0,0 +1,34 @@
+// import debugbreak from "debugbreak";
+// debugbreak(1);
+// debugger;
+
+import { RequireControllerFactory } from "../require/RequireController";
+import { SocketFunction } from "../SocketFunction";
+import { getArgs } from "../src/args";
+import { Test } from "./shared";
+import path from "path";
+import { compileTransform, compileTransformBefore } from "typenode";
+
+// Must add CSS shim before we import any clientside files
+//  NOTE: The css shim only need to run serverside, as clientside doesn't run compilation,
+//      and instead just copies serverside module contents.
+import "../require/CSSShim";
+
+// Import clientside files, so they can be whitelisted
+import "./client";
+
+
+void main();
+
+async function main() {
+    SocketFunction.expose(Test);
+
+    let RequireController = RequireControllerFactory(path.dirname(__dirname));
+    SocketFunction.expose(RequireController);
+
+    SocketFunction.setDefaultHTTPCall(RequireController, "requireHTML", "./test/client");
+
+    const port = 2542;
+
+    await SocketFunction.mount({ port });
+}

package/test/shared.ts

@@ -0,0 +1,65 @@
+import { getArgs } from "../src/args";
+import { SocketFunction } from "../SocketFunction";
+
+import "typenode";
+module.moduleContents;
+
+class TestBase {
+    memberVariable = 5;
+
+    async add(lhs: number, rhs: number) {
+        let caller = Test.context.caller?.nodeId;
+        if (!caller) {
+            throw new Error("No caller?");
+        }
+        console.log(`Caller is ${caller}`);
+        return lhs + rhs;
+    }
+
+    async callMe() {
+        let caller = Test.context.caller?.nodeId;
+        if (!caller) {
+            throw new Error("No caller?");
+        }
+        console.log(`Caller is ${caller}`);
+        void (async () => {
+            let seqNum = 1;
+            while (true) {
+                console.log(`Calling client at ${seqNum}`);
+                await Test.nodes[caller].callBack();
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                seqNum++;
+            }
+        })();
+    }
+
+    async callBack() {
+        console.log(`Got callback at ${Date.now()}`);
+    }
+}
+
+export const Test = SocketFunction.register(
+    "80d9f328-72df-4baa-8be8-019c1003d4a2",
+    new TestBase(),
+    {
+        add: {
+            // hooks: [
+            //     async (config) => {
+
+            //     }
+            // ]
+        },
+        callMe: {
+            clientHooks: [
+                async (config) => {
+                    config.call.reconnectTimeout = 2000;
+                }
+            ]
+        },
+        callBack: {
+
+        },
+        //fncNotAsync: {},
+        //notAFnc: {},
+    }
+);

package/socketServer.ts

@@ -1,74 +0,0 @@
-import https from "https";
-import http from "http";
-import net from "net";
-import * as ws from "ws";
-import { performLocalCall } from "./callManager";
-import { CallerContext, CallType, NetworkLocation } from "./SocketFunctionTypes";
-import { callFactoryFromWS } from "./CallInstance";
-import { registerNodeClient } from "./nodeCache";
-import { getCertKeyPair } from "./nodeAuthentication";
-
-export type SocketServerConfig = {
-    port: number;
-    // public sets ip to "0.0.0.0", otherwise it defaults to "127.0.0.1", which
-    //  causes the server to only accept local connections.
-    public?: boolean;
-    ip?: string;
-} & (
-        https.ServerOptions
-    );
-
-export async function startSocketServer(
-    config: SocketServerConfig
-) {
-    let isSecure = "cert" in config || "key" in config || "pfx" in config;
-    if (!isSecure) {
-        let { key, cert } = getCertKeyPair();
-        config.key = key;
-        config.cert = cert;
-    }
-
-    // TODO: Only allow unauthorized for ip certificates, and then for domains use the domain as the nodeId,
-    //  so it is easy to read, and consistent.
-    let server = https.createServer({
-        ...config,
-        rejectUnauthorized: false,
-        requestCert: true
-    });
-    let listenPromise = new Promise<void>((resolve, error) => {
-        server.on("listening", () => {
-            resolve();
-        });
-        server.on("error", e => {
-            error(e);
-        });
-    });
-
-
-    let host = config.ip ?? "127.0.0.1";
-    if (config.public) {
-        host = "0.0.0.0";
-    }
-
-    server.on("request", (request, response) => {
-        // TODO: Handle HTTP requests
-        //  - HTTP CAN have a nodeId, simply through setting cookies
-        //      - Cookies could always be set via a request before we open
-        //          the websocket connection?
-    });
-
-    const webSocketServer = new ws.Server({
-        noServer: true,
-    });
-    server.on("upgrade", (request, socket, upgradeHead) => {
-        webSocketServer.handleUpgrade(request, socket, upgradeHead, async (ws) => {
-            let clientCallFactory = await callFactoryFromWS(ws);
-            registerNodeClient(clientCallFactory);
-        });
-    });
-
-    console.log(`Listening on ${host}:${config.port}`);
-    server.listen(config.port, host);
-
-    return await listenPromise;
-}

package/test.ts

@@ -1,87 +0,0 @@
-import { getArgs } from "./args";
-import { SocketFunction } from "./SocketFunction";
-
-//todonext;
-// Test the server and client
-//  - I guess we will want to be able to namespace identifies so we can test
-//      multiple on the same machine... Let's not use yargs, just argv parsing should be okay?
-
-class Test {
-    memberVariable = 5;
-
-    async add(lhs: number, rhs: number) {
-        return lhs + rhs;
-    }
-
-    async callMe() {
-        let caller = TestClass.context.caller?.nodeId;
-        if (!caller) {
-            throw new Error("No caller?");
-        }
-        console.log(`Caller is ${caller}`);
-        void (async () => {
-            let seqNum = 1;
-            while (true) {
-                console.log(`Calling client at ${seqNum}`);
-                await TestClass.nodes[caller].callBack();
-                await new Promise(resolve => setTimeout(resolve, 1000));
-                seqNum++;
-            }
-        })();
-    }
-
-    async callBack() {
-        console.log(`Got callback at ${Date.now()}`);
-    }
-}
-
-export const TestClass = SocketFunction.register(
-    "80d9f328-72df-4baa-8be8-019c1003d4a2",
-    Test,
-    {
-        add: {
-            // hooks: [
-            //     async (config) => {
-
-            //     }
-            // ]
-        },
-        callMe: {
-            clientHooks: [
-                async (config) => {
-                    config.call.reconnectTimeout = 2000;
-                }
-            ]
-        },
-        callBack: {
-
-        },
-        //fncNotAsync: {},
-        //notAFnc: {},
-    }
-);
-
-void main();
-
-//todonext
-// - Get case where there will never be a reconnection working
-
-async function main() {
-    SocketFunction.expose(Test);
-    const port = 2542;
-    if (getArgs().identity === "server") {
-        await SocketFunction.mount({ port });
-    } else {
-        let serverId = await SocketFunction.connect({ port, address: "localhost" });
-        let test = await TestClass.nodes[serverId].add(1, 2);
-        console.log(`${test}=${1 + 2}`);
-
-        // while (true) {
-        //     let test = await TestClass.nodes[serverId].add(1, 2);
-        //     console.log(`${test}=${1 + 2}`);
-        //     await new Promise(resolve => setTimeout(resolve, 1000));
-        // }
-
-        await TestClass.nodes[serverId].callMe();
-    }
-}