pinokiod 3.8.36 → 3.8.38

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": {
@@ -136,7 +146,7 @@ class Caddy {
               // create a proxy proxy
               // - get next available port and expose
               payload.apps.http.servers[":" + INTERNAL_PORT] = {
-                "listen": [":PORT_PLACEHOLDER_" + ip + ":" + INTERNAL_PORT],
+                "listen": ["0.0.0.0:PORT_PLACEHOLDER_" + ip + ":" + INTERNAL_PORT],
                 "routes": [{
                   "handle": [
                     {
@@ -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] = {}
+                }
+                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)
+
                 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] = {}
+              }
+              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)
+
               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": [
                 {
@@ -316,86 +372,110 @@ class Caddy {
       // caddy_mapping := { IP => HTTPS_DOMAIN }
       let caddy_mapping = this.kernel.peer.caddy(ip)
       console.log({ caddy_mapping })
-      for(let internal_ip in caddy_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": [":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"]
+      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]
+
+          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]
-        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 })
-          // 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 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 })
+
+
+            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"]
+                    }
                   }
                 }
-              }
-            ]
-          })
+              ]
+            })
+          }
+          
         }
       }
     }
@@ -407,15 +487,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 +571,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,11 +616,18 @@ 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])
+    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])
+      }
     }
 
 

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.36",
+  "version": "3.8.38",
   "description": "",
   "main": "index.js",
   "scripts": {

package/server/index.js

@@ -2661,9 +2661,11 @@ 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
       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 +2753,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,

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>
         <% }) %>