socket-function 0.6.0 → 0.7.0

package/SocketFunction.ts

@@ -1,7 +1,7 @@
 import { SocketExposedInterface, CallContextType, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, NetworkLocation, CallerContext, SocketExposedInterfaceClass, CallType } from "./SocketFunctionTypes";
 import { exposeClass, registerClass, registerGlobalClientHook, registerGlobalHook, runClientHooks } from "./src/callManager";
 import { SocketServerConfig, startSocketServer } from "./src/socketServer";
-import { getCallFactoryNodeId, getCreateCallFactoryLocation } from "./src/nodeCache";
+import { getCallFactoryNodeId, getCreateCallFactoryLocation, getNetworkLocationHash } from "./src/nodeCache";
 import { getCallProxy } from "./src/nodeProxy";
 import { Args } from "./src/types";
 import { setDefaultHTTPCall } from "./src/callHTTPHandler";
@@ -46,9 +46,9 @@ export class SocketFunction {
         registerClass(classGuid, instance as SocketExposedInterface, shape as any as SocketExposedShape);
 
         let nodeProxy = getCallProxy(classGuid, async (nodeId, functionName, args) => {
-            let callFactory = getCallFactoryNodeId(nodeId);
+            let callFactory = await getCallFactoryNodeId(nodeId);
             if (!callFactory) {
-                throw new Error(`Cannot reach node ${nodeId}. Either it was established via an HTTP call, or was incorrect provided to us via another node, which should have provided us a NetworkLocation instead.`);
+                throw new Error(`Cannot reach node ${nodeId}. It might have been incorrect provided to us via another node, which should have provided us a NetworkLocation instead.`);
             }
 
             let shapeObj = shape[functionName];
@@ -123,6 +123,20 @@ export class SocketFunction {
         return await getCreateCallFactoryLocation(location);
     }
 
+    public static connectSync(location: NetworkLocation | { address: string; port: number }): string {
+        if (!("localPort" in location)) {
+            location = {
+                address: location.address,
+                listeningPorts: [location.port],
+                localPort: 0,
+            };
+        }
+        let tempNodeId = "syncTempNodeId_" + getNetworkLocationHash(location);
+
+        void getCreateCallFactoryLocation(location, tempNodeId);
+
+        return tempNodeId;
+    }
 
     public static addGlobalHook<CallContext extends CallContextType>(hook: SocketFunctionHook<SocketExposedInterface, CallContext>) {
         registerGlobalHook(hook as SocketFunctionHook);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.6.0",
+	"version": "0.7.0",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/require/RequireController.ts

@@ -144,7 +144,6 @@ class RequireControllerBase {
             let moduleObj = modules[module.filename];
             if (moduleObj.allowclient) {
                 moduleObj.source = module.moduleContents;
-                // TODO: Check timestamps on .json file and get most recent value
                 if (module.filename.endsWith(".json") && !moduleObj.source) {
                     moduleObj.source = module.moduleContents = fs.readFileSync(module.filename).toString();
                 }

package/spec.txt

@@ -11,6 +11,15 @@ spec.txt
         certs very easy.
         - ALTHOUGH, maybe this should just be a downstream user of socket-function thing, and not
             a requirement of socket-function?
+            - This will be something where machines ask a server for an identity, and then the owner
+                allows it (giving them a subdomain), verifying their ip, etc.
+                - MAYBE we just automatically allow it? This works if we never use the root domain for anything,
+                    and only use subdomains?
+                    - Although, of course, sometimes we WILL want to group by domain, so it is more than just
+                        identity, so having a way for the owner to authenticate it might be nice as well...
+                - Once they are given an identity, they are allowed to request their certs are updated,
+                    and to get the new certs (it probably won't happen automatically, so that we can create
+                    many nodes and let them die, without having to try to track which still need certs to be updated)
         - ALSO, remember, for domains, use the domain as the nodeId, not the public key, that way it
             is more consistent.
 

package/src/nodeCache.ts

@@ -14,11 +14,11 @@ import { MaybePromise } from "./types";
 
 // nodeId => 
 const nodeCache = new Map<string, {
-    callFactory: CallFactory;
+    callFactory: MaybePromise<CallFactory>;
 }>();
 const locationLookup = new Map<string, MaybePromise<string>>();
 
-function getNetworkLocationHash(location: NetworkLocation): string {
+export function getNetworkLocationHash(location: NetworkLocation): string {
     return location.address + ":" + location.localPort + "=" + location.listeningPorts.join("|");
 }
 
@@ -37,9 +37,12 @@ export function registerNodeClient(callFactory: CallFactory) {
     // Never go from listening ports to no listening ports. Worst case the listening ports are old
     //  and won't work, in which case... we won't be able to reconnect, which basically what
     //  we would do if there were no listening ports.
-    let prevListeningPorts = nodeCache.get(nodeId)?.callFactory.location.listeningPorts;
-    if (prevListeningPorts && !callFactory.location.listeningPorts.length) {
-        callFactory.location.listeningPorts = prevListeningPorts;
+    let prevFactory = nodeCache.get(nodeId)?.callFactory;
+    if (prevFactory && !(prevFactory instanceof Promise)) {
+        let prevListeningPorts = prevFactory.location.listeningPorts;
+        if (prevListeningPorts && !callFactory.location.listeningPorts.length) {
+            callFactory.location.listeningPorts = prevListeningPorts;
+        }
     }
     // TODO: Maybe even preserve the address in some cases, such as if it was a domain, and is now an ip?
     nodeCache.set(nodeId, {
@@ -47,7 +50,7 @@ export function registerNodeClient(callFactory: CallFactory) {
     });
 }
 
-export function getCreateCallFactoryLocation(location: NetworkLocation): MaybePromise<string> {
+export function getCreateCallFactoryLocation(location: NetworkLocation, tempNodeId?: string): MaybePromise<string> {
     let locationHash = getNetworkLocationHash(location);
     let nodeId = locationLookup.get(locationHash);
     if (nodeId !== undefined) {
@@ -58,12 +61,22 @@ export function getCreateCallFactoryLocation(location: NetworkLocation): MaybePr
     let nodeIdPromise = callFactoryPromise.then(x => x.nodeId);
     locationLookup.set(locationHash, nodeIdPromise);
 
+    if (tempNodeId !== undefined) {
+        nodeCache.set(tempNodeId, {
+            callFactory: callFactoryPromise,
+        });
+    }
+
     return callFactoryPromise.then(callFactory => {
         let nodeId = callFactory.nodeId;
         // TODO: Maybe warn if we just clobbered a nodeId?
         let prevEntry = nodeCache.get(nodeId);
         if (prevEntry) {
-            console.warn(`Clobbering nodeId ${nodeId}, with a new location ${locationHash}, was ${getNetworkLocationHash(prevEntry.callFactory.location)}. (This might indiciate multiple locations with the same nodeId, which could cause an issue. If this happens repeatedly it will cause stability issues).`);
+            if (prevEntry.callFactory instanceof Promise) {
+                console.warn(`Clobbering nodeId ${nodeId}, with a new location ${locationHash}, which was still resolving. (This might indiciate multiple locations with the same nodeId, which could cause an issue. If this happens repeatedly it will cause stability issues).`);
+            } else {
+                console.warn(`Clobbering nodeId ${nodeId}, with a new location ${locationHash}, was ${getNetworkLocationHash(prevEntry.callFactory.location)}. (This might indiciate multiple locations with the same nodeId, which could cause an issue. If this happens repeatedly it will cause stability issues).`);
+            }
         }
         nodeCache.set(nodeId, {
             callFactory,
@@ -74,6 +87,6 @@ export function getCreateCallFactoryLocation(location: NetworkLocation): MaybePr
 
 
 // TODO: Give a special error if the nodeId has been seen, but is only one-way (from HTTP requests).
-export function getCallFactoryNodeId(nodeId: string): CallFactory | undefined {
-    return nodeCache.get(nodeId)?.callFactory;
+export async function getCallFactoryNodeId(nodeId: string): Promise<CallFactory | undefined> {
+    return await nodeCache.get(nodeId)?.callFactory;
 }

package/src/nodeProxy.ts

@@ -1,10 +1,6 @@
 import { lazy } from "./caching";
 import { SocketExposedInterface } from "../SocketFunctionTypes";
 
-//todonext
-//  We need some sort of cache, but... maybe not here?
-//  Proxy => callback?
-
 type CallProxyType = {
     [controllerName: string]: SocketExposedInterface;
 };