pinokiod 3.8.37 → 3.8.39

package/kernel/caddy.js

@@ -37,10 +37,20 @@ class Caddy {
     let internal_ip = "127.0.0.1:42000"
     let namespaced_url = "pinokio.localhost"
 
-    if (!this._mapping[internal_ip]) {
-      this._mapping[internal_ip] = new Set()
+    let current_lan_ip = this.kernel.peer.current_ip
+    let current_lan_username = this.kernel.peer.account(current_lan_ip)
+
+    //if (!this._mapping[internal_ip]) {
+    //  this._mapping[internal_ip] = new Set()
+    //}
+    //this._mapping[internal_ip].add(namespaced_url)
+    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[internal_ip].add(namespaced_url)
+    this._mapping[current_lan_ip][internal_ip].add(namespaced_url)
 
     return {
       "apps": {
@@ -158,13 +168,25 @@ class Caddy {
                 }]
               }
 
+              let current_lan_ip = ip
+              let current_lan_username = this.kernel.peer.account(ip)
+
               // proxy proxy => proxy
               if (key === "url") {
                 let namespaced_url = `${name}.${account}.localhost`.toLowerCase()
-                if (!this._mapping[internal_ip]) {
-                  this._mapping[internal_ip] = new Set()
+                //if (!this._mapping[internal_ip]) {
+                //  this._mapping[internal_ip] = new Set()
+                //}
+                //this._mapping[internal_ip].add(namespaced_url)
+
+                if (!this._mapping[current_lan_ip]) {
+                  this._mapping[current_lan_ip] = {}
                 }
-                this._mapping[internal_ip].add(namespaced_url)
+                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)
+
                 payload.apps.http.servers.main.routes.push({
                   "match": [{
                     "host": [namespaced_url]
@@ -189,10 +211,19 @@ class Caddy {
                 })
               }
               let namespaced_url = `${name}.${account}.localhost`.toLowerCase()
-              if (!this._mapping[internal_ip]) {
-                this._mapping[internal_ip] = new Set()
+              //if (!this._mapping[internal_ip]) {
+              //  this._mapping[internal_ip] = new Set()
+              //}
+              //this._mapping[internal_ip].add(namespaced_url)
+
+              if (!this._mapping[current_lan_ip]) {
+                this._mapping[current_lan_ip] = {}
               }
-              this._mapping[internal_ip].add(namespaced_url)
+              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)
+
               payload.apps.http.servers.main.routes.push({
                 "match": [{
                   "host": [namespaced_url],
@@ -246,14 +277,27 @@ class Caddy {
           let chunks = internal_ip.split(":")
           if (chunks.length === 2) {
             if (key === "url") {
-              let url = `${name}.localhost`.toLowerCase()
-              if (!this._mapping[val]) {
-                this._mapping[val] = new Set()
+              //if (!this._mapping[val]) {
+              //  this._mapping[val] = new Set()
+              //}
+              //this._mapping[val].add(namespaced_url)
+
+
+
+              let namespaced_url = `${name}.localhost`.toLowerCase()
+              let current_lan_ip = this.kernel.peer.current_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[val].add(url)
+              this._mapping[current_lan_ip][internal_ip].add(namespaced_url)
+
               payload.apps.http.servers.main.routes.push({
                 "match": [{
-                  "host": [url]
+                  "host": [namespaced_url]
                 }],
                 "handle": [
                   {
@@ -274,9 +318,21 @@ class Caddy {
                 ]
               })
             }
+            let namespaced_url = `${key}.${name}.localhost`.toLowerCase()
+
+            let current_lan_ip = this.kernel.peer.current_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)
+
             payload.apps.http.servers.main.routes.push({
               "match": [{
-                "host": [`${key}.${name}.localhost`.toLowerCase()],
+                "host": [namespaced_url],
               }],
               "handle": [
                 {
@@ -313,10 +369,24 @@ class Caddy {
       let account = this.kernel.peer.account(ip)
       console.log({ account })
 
+      // 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
+
+
       // caddy_mapping := { IP => HTTPS_DOMAIN }
-      let caddy_mapping = this.kernel.peer.caddy(ip)
-      console.log({ caddy_mapping })
-      for(let internal_ip in caddy_mapping) {
+
+      // 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
@@ -348,7 +418,10 @@ class Caddy {
             ]
           }]
         }
-        let https_domains = caddy_mapping[internal_ip]
+
+
+        //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,
@@ -365,14 +438,30 @@ class Caddy {
             namespaced_url = chunks.join(".")
           }
           console.log("##x", { chunks, namespaced_url, https_domain })
-          if (!this._mapping[internal_ip]) {
-            this._mapping[internal_ip] = new Set()
+
+
+          //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()
           }
-          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 })
+          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": [{
@@ -407,15 +496,28 @@ class Caddy {
     if (!list) {
       list = await this.kernel.processes.refresh()
     }
+    console.log(">>>>>>>>>> LIST", list)
     for(let item of list) {
-      let url = `${item.port}.localhost`
-      if (!this._mapping[item.ip]) {
-        this._mapping[item.ip] = new Set()
+      let namespaced_url = `${item.port}.localhost`
+      //if (!this._mapping[item.ip]) {
+      //  this._mapping[item.ip] = new Set()
+      //}
+      //this._mapping[item.ip].add(namespaced_url)
+
+      let internal_ip = item.ip
+      let current_lan_ip = this.kernel.peer.current_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[item.ip].add(url)
+      this._mapping[current_lan_ip][internal_ip].add(namespaced_url)
+
       payload.apps.http.servers.main.routes.push({
         "match": [{
-          "host": [url],
+          "host": [namespaced_url],
         }],
         "handle": [
           {
@@ -478,13 +580,32 @@ class Caddy {
     // replace :PORT_PLACEHOLDER with available ports
 
     const jsonString = JSON.stringify(payload)
-    const matches = jsonString.match(/:PORT_PLACEHOLDER/g);
-    const count = matches ? matches.length : 0;
+    // find all PORT_PLACEHOLDER patterns
+    const matches = jsonString.match(/:PORT_PLACEHOLDER_[0-9.:]+/g)
+    console.log("matches", matches)
+
+    // iterate through them and see if the port already exists
+    let count = 0
+    if (matches) {
+      for(let match of matches) {
+        console.log("testing", match)
+        const port_match = match.match(/[0-9.]+:([0-9]+)/);
+        let port = port_match ? port_match[1] : null
+        console.log({ port, port_match })
+        if (port && !this.port_mapping[port]) {
+          count++
+        }
+      }
+    }
+
+    console.log("count", count)
+    console.log("&&", JSON.stringify(payload, null, 2))
  
     if (count > 0) {
       let ports = await this.kernel.ports(count)
       console.log({ count, ports })
-      let response = Util.fill_object(payload, /PORT_PLACEHOLDER_.+/, ports)
+      console.log("PORT_CACHE", this.port_cache)
+      let response = Util.fill_object(payload, /PORT_PLACEHOLDER_.+/, ports, this.port_cache)
       payload = response.result
       let replaced_map = response.replaced_map
       for(let key in replaced_map) {
@@ -504,15 +625,33 @@ class Caddy {
         //let original_port = key.replace("PORT_PLACEHOLDER_", "")
         this.port_mapping[original_port] = replaced_map[key]
       }
+      this.port_cache = replaced_map
     }
 
-    this.mapping = {}
-    for(let key in this._mapping) {
-      this.mapping[key] = Array.from(this._mapping[key])
-    }
+
+
 
 
     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/kernel/util.js

@@ -307,19 +307,24 @@ const update_env = async (filepath, changes) => {
   }, normalizeEOL(env));
   await fs.promises.writeFile(filepath, newval)
 };
-function fill_object(obj, pattern, list) {
+function fill_object(obj, pattern, list, cache) {
   console.log("FILL_OBJECT")
   const map = {};
-  const replaced_map = {}
+  const replaced_map = cache || {}
   let index = 0;
 
   function recurse(value) {
     if (typeof value === 'string') {
       return value.replace(pattern, (match) => {
         if (!(match in map)) {
-          if (index >= list.length) throw new Error("Not enough items provided");
-          map[match] = list[index++];
-          replaced_map[match] = map[match]
+          console.log( "fill_object", { replaced_map, match })
+          if (replaced_map[match]) {
+            map[match] = replaced_map[match]
+          } else {
+            if (index >= list.length) throw new Error("Not enough items provided");
+            map[match] = list[index++];
+            replaced_map[match] = map[match]
+          }
         }
         return map[match];
       });

package/package.json

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

package/server/index.js

@@ -2661,9 +2661,12 @@ class Server {
     this.app.get("/proxy", ex(async (req, res) => {
       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[item.ip] || [],
+          proxy: this.kernel.caddy.mapping()[current_lan_ip][item.ip] || [],
           ...item
         }
       })
@@ -2751,7 +2754,7 @@ class Server {
         }
       }
 
-      console.log({ port_mapping: this.kernel.caddy.port_mapping, ip_mapping: this.kernel.caddy.ip_mapping })
+      console.log({ port_mapping: this.kernel.caddy.port_mapping, ip_mapping: this.kernel.caddy.ip_mapping, lan: this.kernel.caddy.local_network_mapping, ip: this.kernel.peer.current_ip })
       res.render("proxy", {
         ip: this.kernel.peer.current_ip,
         peers,
@@ -3291,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,

package/server/views/proxy.ejs

@@ -274,9 +274,11 @@ td:first-child, th:first-child {
               <div>
                 <a target="_blank" href="http://localhost:<%=item.port%>">http://localhost:<%=item.port%></a>
               </div>
-              <div>
-                <a target="_blank" href="http://<%=ip%>:<%=lan[ip][item.port]%>">http://<%=ip%>:<%=lan[ip][item.port]%></a>
-              </div>
+              <% if (lan[ip]) { %>
+                <div>
+                  <a target="_blank" href="http://<%=ip%>:<%=lan[ip][item.port]%>">http://<%=ip%>:<%=lan[ip][item.port]%></a>
+                </div>
+              <% } %>
             </td>
           </tr>
         <% }) %>