pinokiod 3.8.38 → 3.8.39

package/kernel/caddy.js

@@ -369,113 +369,122 @@ class Caddy {
       let account = this.kernel.peer.account(ip)
       console.log({ account })
 
-      // caddy_mapping := { IP => HTTPS_DOMAIN }
-      let caddy_mapping = this.kernel.peer.caddy(ip)
-      console.log({ caddy_mapping })
-      for(let lan_ip in caddy_mapping) {
-        let https_domains_mapping = caddy_mapping[lan_ip]
-        for(let internal_ip in https_domains_mapping) {
-
-          // create a proxy proxy
-          // 1. create an exposed port listening on 0.0.0.0
-          // 2. the exposed port points to the internal ip
-          let chunks = internal_ip.split(":")
-          let INTERNAL_HOST = chunks[0]
-          let INTERNAL_PORT = chunks[1]
+      // if ip === current_lan_ip
+      //  => trust the info on itself only
+      //  => only use the current info, ignore the rest
+      // ip ip !== current_lan_ip => just pick one 
+      //  => trust the info coming from ip only
+      //  => only use the info for that node
 
-          this.ip_mapping[INTERNAL_PORT] = ip
 
-          payload.apps.http.servers[":" + INTERNAL_PORT] = {
-            "listen": ["0.0.0.0:PORT_PLACEHOLDER_" + ip + ":" + INTERNAL_PORT],
-            "routes": [{
-              "handle": [
-                {
-                  "handler": "reverse_proxy",
-                  "upstreams": [{ "dial": internal_ip }]
-                },
-                {
-                  "handler": "headers",
-                  "response": {
-                    "set": {
-                      "Access-Control-Allow-Origin": ["*"],
-                      "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
-                      "Access-Control-Allow-Headers": ["*"],
-                      "Vary": ["Origin"]
-                    }
+      // caddy_mapping := { IP => HTTPS_DOMAIN }
+
+      // get the mapping for the current node
+      // for current node, only trust the info from the current node
+      // for other nodes, just use the first one to avoid registering duplicates
+
+      let https_domains_mapping = this.mapping(ip)[ip]
+      console.log({ https_domains_mapping, ip })
+      for(let internal_ip in https_domains_mapping) {
+
+        // create a proxy proxy
+        // 1. create an exposed port listening on 0.0.0.0
+        // 2. the exposed port points to the internal ip
+        let chunks = internal_ip.split(":")
+        let INTERNAL_HOST = chunks[0]
+        let INTERNAL_PORT = chunks[1]
+
+        this.ip_mapping[INTERNAL_PORT] = ip
+
+        payload.apps.http.servers[":" + INTERNAL_PORT] = {
+          "listen": ["0.0.0.0:PORT_PLACEHOLDER_" + ip + ":" + INTERNAL_PORT],
+          "routes": [{
+            "handle": [
+              {
+                "handler": "reverse_proxy",
+                "upstreams": [{ "dial": internal_ip }]
+              },
+              {
+                "handler": "headers",
+                "response": {
+                  "set": {
+                    "Access-Control-Allow-Origin": ["*"],
+                    "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
+                    "Access-Control-Allow-Headers": ["*"],
+                    "Vary": ["Origin"]
                   }
                 }
-              ]
-            }]
-          }
+              }
+            ]
+          }]
+        }
 
 
-          //let https_domains = caddy_mapping[internal_ip]
-          let https_domains = https_domains_mapping[internal_ip]
-          console.log(">>>>>>>> https_domains", https_domains)
-
-          // 1. if https_domains is made up of one item <port>.localhost,
-          // add <port>.<account>.localhost
-          // 2. if https_domains is made up of two items <port>.localhost and <port>.<account>.localhost, don't do anything
-          for(let https_domain of https_domains) {
-            // insert the $account value right before the last part (1234.localhost => 1234.x.localhost)
-            let chunks = https_domain.split(".")
-            let namespaced_url
-            if (chunks.length === 3) {
-              namespaced_url = https_domain
-            } else if (chunks.length === 2) {
-              chunks.splice(chunks.length - 1, 0, account)
-              namespaced_url = chunks.join(".")
-            }
-            console.log("##x", { chunks, namespaced_url, https_domain })
+        //let https_domains = caddy_mapping[internal_ip]
+        let https_domains = https_domains_mapping[internal_ip]
+        console.log(">>>>>>>> https_domains", https_domains)
+
+        // 1. if https_domains is made up of one item <port>.localhost,
+        // add <port>.<account>.localhost
+        // 2. if https_domains is made up of two items <port>.localhost and <port>.<account>.localhost, don't do anything
+        for(let https_domain of https_domains) {
+          // insert the $account value right before the last part (1234.localhost => 1234.x.localhost)
+          let chunks = https_domain.split(".")
+          let namespaced_url
+          if (chunks.length === 3) {
+            namespaced_url = https_domain
+          } else if (chunks.length === 2) {
+            chunks.splice(chunks.length - 1, 0, account)
+            namespaced_url = chunks.join(".")
+          }
+          console.log("##x", { chunks, namespaced_url, https_domain })
 
 
-            //if (!this._mapping[internal_ip]) {
-            //  this._mapping[internal_ip] = new Set()
-            //}
-            //console.log("this.mapping", this._mapping)
-            //console.log("internal_ip", internal_ip)
-            //console.log("result", this._mapping[internal_ip])
-            //this._mapping[internal_ip].add(namespaced_url)
-            //console.log({ namespaced_url, https_domain,  internal_ip })
+          //if (!this._mapping[internal_ip]) {
+          //  this._mapping[internal_ip] = new Set()
+          //}
+          //console.log("this.mapping", this._mapping)
+          //console.log("internal_ip", internal_ip)
+          //console.log("result", this._mapping[internal_ip])
+          //this._mapping[internal_ip].add(namespaced_url)
+          //console.log({ namespaced_url, https_domain,  internal_ip })
 
 
-            let current_lan_ip = ip
-            let current_lan_username = this.kernel.peer.account(current_lan_ip)
-            if (!this._mapping[current_lan_ip]) {
-              this._mapping[current_lan_ip] = {}
-            }
-            if (!this._mapping[current_lan_ip][internal_ip]) {
-              this._mapping[current_lan_ip][internal_ip] = new Set()
-            }
-            this._mapping[current_lan_ip][internal_ip].add(namespaced_url)
-            console.log({ internal_ip, current_lan_ip })
-
-
-            // 1. point proxy URL to the 127.0.0.1:EXPOSED_PORT
-            payload.apps.http.servers.main.routes.push({
-              "match": [{
-                "host": [namespaced_url],
-              }],
-              "handle": [
-                {
-                  "handler": "reverse_proxy",
-                  "upstreams": [{ "dial": ip + ":PORT_PLACEHOLDER_" + ip + ":" + INTERNAL_PORT }]
-                },
-                {
-                  "handler": "headers",
-                  "response": {
-                    "set": {
-                      "Access-Control-Allow-Origin": ["*"],
-                      "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
-                      "Access-Control-Allow-Headers": ["*"],
-                      "Vary": ["Origin"]
-                    }
+          let current_lan_ip = ip
+          let current_lan_username = this.kernel.peer.account(current_lan_ip)
+          if (!this._mapping[current_lan_ip]) {
+            this._mapping[current_lan_ip] = {}
+          }
+          if (!this._mapping[current_lan_ip][internal_ip]) {
+            this._mapping[current_lan_ip][internal_ip] = new Set()
+          }
+          this._mapping[current_lan_ip][internal_ip].add(namespaced_url)
+          console.log("Adding", current_lan_ip, internal_ip, namespaced_url)
+
+
+          // 1. point proxy URL to the 127.0.0.1:EXPOSED_PORT
+          payload.apps.http.servers.main.routes.push({
+            "match": [{
+              "host": [namespaced_url],
+            }],
+            "handle": [
+              {
+                "handler": "reverse_proxy",
+                "upstreams": [{ "dial": ip + ":PORT_PLACEHOLDER_" + ip + ":" + INTERNAL_PORT }]
+              },
+              {
+                "handler": "headers",
+                "response": {
+                  "set": {
+                    "Access-Control-Allow-Origin": ["*"],
+                    "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
+                    "Access-Control-Allow-Headers": ["*"],
+                    "Vary": ["Origin"]
                   }
                 }
-              ]
-            })
-          }
-          
+              }
+            ]
+          })
         }
       }
     }
@@ -619,19 +628,30 @@ class Caddy {
       this.port_cache = replaced_map
     }
 
-    this.mapping = {}
-    for(let lan_ip in this._mapping) {
-      let internal_maps = this._mapping[lan_ip]
-      if (!this.mapping[lan_ip]) {
-        this.mapping[lan_ip] = {}
-      }
-      for(let url in internal_maps) {
-        this.mapping[lan_ip][url] = Array.from(internal_maps[url])
-      }
-    }
+
+
 
 
     return payload
   }
+  mapping (ip) {
+    let current_lan_ip = this.kernel.peer.current_ip
+    if (!ip || current_lan_ip === ip) {
+      let mapping = {}
+      for(let lan_ip in this._mapping) {
+        let internal_maps = this._mapping[lan_ip]
+        if (!mapping[lan_ip]) {
+          mapping[lan_ip] = {}
+        }
+        for(let url in internal_maps) {
+          mapping[lan_ip][url] = Array.from(internal_maps[url])
+        }
+      }
+      return mapping
+    } else {
+      return this.kernel.peer.caddy(ip)
+    }
+  }
+
 }
 module.exports = Caddy

package/kernel/peer.js

@@ -39,6 +39,7 @@ class PeerDiscovery {
           let interval = setInterval(() => {
             axios.get(`http://${ip}:42000/pinokio/mem`).then((res) => {
               this.data[ip] = res.data
+              console.log("this.data", { ip, data: this.data[ip] })
               if (res.data.proxy) {
 //                clearInterval(interval)
               }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "3.8.38",
+  "version": "3.8.39",
   "description": "",
   "main": "index.js",
   "scripts": {

package/server/index.js

@@ -2662,10 +2662,11 @@ class Server {
       await this.kernel.caddy.update()
       let list = await this.kernel.processes.refresh()
       let current_lan_ip = this.kernel.peer.current_ip
+      console.log("this.kernel.caddy.mapping", this.kernel.caddy.mapping())
       list = list.map((item) => {
         return {
           //proxy: this.kernel.caddy.mapping[item.ip] || [],
-          proxy: this.kernel.caddy.mapping[current_lan_ip][item.ip] || [],
+          proxy: this.kernel.caddy.mapping()[current_lan_ip][item.ip] || [],
           ...item
         }
       })
@@ -3293,7 +3294,7 @@ class Server {
       res.json({
         homedir: this.kernel.homedir,
         account: this.kernel.peer.current_account,
-        proxy: this.kernel.caddy.mapping, // mapping: { IP => https_domain }
+        proxy: this.kernel.caddy.mapping(), // mapping: { IP => https_domain }
         ports: this.kernel.caddy.port_mapping,
         lan: this.kernel.caddy.local_network_mapping,
         ips: this.kernel.caddy.ip_mapping,