pinokiod 3.8.149 → 3.8.151

package/kernel/caddy2.js

@@ -1,666 +0,0 @@
-const axios = require('axios')
-const path = require('path')
-const Util = require('./util')
-class Caddy {
-  constructor(kernel) {
-    this.kernel = kernel
-  }
-  peers_home (payload) {
-    let peers = this.kernel.peer.get()
-    for(let ip of peers) {
-      let account = this.kernel.peer.account(ip)
-      let namespaced_url = `pinokio.${account}.localhost`
-      payload.apps.http.servers.main.routes.push({
-        "match": [{ "host": [namespaced_url] }],
-        "handle": [
-          {
-            "handler": "reverse_proxy",
-            "upstreams": [{ "dial": `${ip}:42000` }]
-          },
-          {
-            "handler": "headers",
-            "response": {
-              "set": {
-                "Access-Control-Allow-Origin": ["*"],
-                "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
-                "Access-Control-Allow-Headers": ["*"],
-                "Vary": ["Origin"]
-              }
-            }
-          }
-        ]
-      })
-    }
-    return payload
-  }
-  home () {
-    let internal_ip = "127.0.0.1:42000"
-    let namespaced_url = "pinokio.localhost"
-
-    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[current_lan_ip][internal_ip].add(namespaced_url)
-
-    return {
-      "apps": {
-        "http": {
-          "servers": {
-            "main": {
-              "listen": [":443"],
-              "routes": [
-                {
-                  "match": [{ "method": ["OPTIONS"] }],
-                  "handle": [
-                    {
-                      "handler": "headers",
-                      "response": {
-                        "set": {
-                          "Access-Control-Allow-Origin": ["*"],
-                          "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
-                          "Access-Control-Allow-Headers": ["*"],
-                          "Vary": ["Origin"],
-                          "X-Forwarded-Proto": ["https"],
-                          "X-Forwarded-Host": ["{http.request.host}"]
-                        }
-                      }
-                    },
-                    {
-                      "handler": "static_response",
-                      "status_code": 204
-                    }
-                  ]
-                },
-                {
-                  "match": [{ "host": [namespaced_url] }],
-                  "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"]
-                        }
-                      }
-                    }
-                  ]
-                },
-              ]
-            }
-          }
-        }
-      }
-    }
-  }
-  async peers_locals(payload) {
-    let peers = this.kernel.peer.get()
-    for(let ip of peers) {
-      let account = this.kernel.peer.account(ip)
-      let local = this.kernel.peer.local(ip)
-      // construct Caddy update payload
-      console.log({ local })
-      for(let script_path in local) {
-        let local_variables = local[script_path]
-        console.log({ local_variables })
-        for(let key in local_variables) {
-          let val = local_variables[key]
-          if (val.startsWith("http")) {
-
-            // val :- https?:(some url)
-
-
-            let internal_ip = val.replace(/https?:\/\//, '')
-
-            let api_path = path.resolve(this.kernel.peer.homedir(ip), "api")
-            let rel_path = path.relative(api_path, script_path)
-            let name = rel_path.split(path.sep)[0]
-            console.log({ api_path, rel_path, name, internal_ip })
-
-            let chunks = internal_ip.split(":")
-            if (chunks.length === 2) {
-              // 1. if the URL is a localhost url with port
-              let INTERNAL_HOST = chunks[0]
-              let INTERNAL_PORT = chunks[1]
-
-              this.ip_mapping[INTERNAL_PORT] = ip
-
-
-              // replace 127,0.0.1 or localhost with the 192.168 address
-              //val = val.replace(/localhost|127\.0\.0\.1/g, ip)
-
-
-              // create a proxy proxy
-              // - get next available port and expose
-              payload.apps.http.servers[ip + ":" + 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 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()
-                console.log("Adding namespaced_url 1", { name, account, namespaced_url })
-                //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[current_lan_ip][internal_ip].add(namespaced_url)
-
-                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 namespaced_url = `${key}.${name}.${account}.localhost`.toLowerCase()
-              console.log("Adding namespaced_url 2", { name, account, namespaced_url })
-              //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[current_lan_ip][internal_ip].add(namespaced_url)
-
-              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"]
-                      }
-                    }
-                  }
-                ]
-              })
-            } else {
-              
-              // 2. if otherwise (anything, like https://google.com)
-              // DO NOT create a proxy
-            }
-
-          }
-        }
-      }
-    }
-    return payload
-  }
-  locals (payload) {
-    // construct Caddy update payload
-    let local = this.kernel.memory.local;
-    console.log({ local })
-    for(let script_path in local) {
-      let local_variables = local[script_path]
-      console.log({ local_variables })
-      for(let key in local_variables) {
-        let val = local_variables[key]
-        if (val.startsWith("http")) {
-          val = val.replace(/https?:\/\//, '')
-          let internal_ip = val
-          let api_path = this.kernel.path("api")
-          let rel_path = path.relative(api_path, script_path)
-          let name = rel_path.split(path.sep)[0]
-          console.log({ api_path, rel_path, name, val })
-          let chunks = internal_ip.split(":")
-          if (chunks.length === 2) {
-            if (key === "url") {
-              //if (!this._mapping[val]) {
-              //  this._mapping[val] = new Set()
-              //}
-              //this._mapping[val].add(namespaced_url)
-
-
-
-              let namespaced_url = `${name}.localhost`.toLowerCase()
-              console.log("Adding namespaced_url 3", { name, namespaced_url })
-              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": [namespaced_url]
-                }],
-                "handle": [
-                  {
-                    "handler": "reverse_proxy",
-                    "upstreams": [{ "dial": val }]
-                  },
-                  {
-                    "handler": "headers",
-                    "response": {
-                      "set": {
-                        "Access-Control-Allow-Origin": ["*"],
-                        "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
-                        "Access-Control-Allow-Headers": ["*"],
-                        "Vary": ["Origin"]
-                      }
-                    }
-                  }
-                ]
-              })
-            }
-            let namespaced_url = `${key}.${name}.localhost`.toLowerCase()
-            console.log("Adding namespaced_url 4", { key, name, namespaced_url })
-
-            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": [namespaced_url],
-              }],
-              "handle": [
-                {
-                  "handler": "reverse_proxy",
-                  "upstreams": [{ "dial": val }]
-                },
-                {
-                  "handler": "headers",
-                  "response": {
-                    "set": {
-                      "Access-Control-Allow-Origin": ["*"],
-                      "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
-                      "Access-Control-Allow-Headers": ["*"],
-                      "Vary": ["Origin"]
-                    }
-                  }
-                }
-              ]
-            })
-          } else {
-            // 2. if otherwise (anything, like https://google.com)
-            // do NOT create a proxy
-          }
-        }
-      }
-    }
-    return payload
-  }
-  async peers_procs (payload) {
-    console.log("####### procs", payload)
-    let list = this.kernel.peer.get()
-    console.log(">> peers list", list)
-    for(let ip of list) {
-      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 }
-
-      // 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[ip + ":" + 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 (https_domain.endsWith(`${account}.localhost`)) {
-            // already accountified
-            namespaced_url = https_domain
-          } else {
-            chunks.splice(chunks.length - 1, 0, account)
-            namespaced_url = chunks.join(".")
-          }
-
-//          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("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"]
-                  }
-                }
-              }
-            ]
-          })
-        }
-      }
-    }
-    return payload
-  }
-  async procs (payload) {
-    console.log("####### procs", payload)
-    let list = this.kernel.processes.list
-    if (!list) {
-      list = await this.kernel.processes.refresh()
-    }
-    console.log(">>>>>>>>>> LIST", list)
-    for(let item of list) {
-      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[current_lan_ip][internal_ip].add(namespaced_url)
-
-      payload.apps.http.servers.main.routes.push({
-        "match": [{
-          "host": [namespaced_url],
-        }],
-        "handle": [
-          {
-            "handler": "reverse_proxy",
-            "upstreams": [{ "dial": item.ip }]
-          },
-          {
-            "handler": "headers",
-            "response": {
-              "set": {
-                "Access-Control-Allow-Origin": ["*"],
-                "Access-Control-Allow-Methods": ["GET, POST, OPTIONS, PUT, DELETE"],
-                "Access-Control-Allow-Headers": ["*"],
-                "Vary": ["Origin"]
-              }
-            }
-          }
-        ]
-      })
-    }
-    return payload
-  }
-  peers(payload) {
-    let peers = this.kernel.peer.get()
-    for(let peer of peers) {
-      let account = peer.username
-    }
-  }
-  async update() {
-    let payload = await this.payload()
-    console.log("Make request to caddy", JSON.stringify(payload, null, 2))
-    let response = await axios.post('http://127.0.0.1:2019/load', payload, {
-      headers: { 'Content-Type': 'application/json' }
-    }).catch((e) => {
-      console.log("EEEEEEEEEEEEE", e)
-    })
-    console.log("Caddy Response", { response })
-  }
-  async payload () {
-    this._mapping = {}
-    this.ip_mapping = {}
-    this.port_mapping = {}   // 127.0.0.1 => 192.168,..
-    this.local_network_mapping = {}
-
-    // localhost home
-    let payload = this.home()
-    // peers home
-    let peers = this.kernel.peer.get()
-    payload = this.peers_home(payload)
-
-    // localhost local variables
-    payload = this.locals(payload)
-    // peers local variables
-    payload = await this.peers_locals(payload)
-
-    payload = await this.procs(payload)
-    payload = await this.peers_procs(payload)
-
-
-    // replace :PORT_PLACEHOLDER with available ports
-
-    const jsonString = JSON.stringify(payload)
-    // 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) {
-        const port_match = match.match(/[0-9.]+:([0-9]+)/);
-        let port = port_match ? port_match[1] : null
-        if (port && !this.port_mapping[port]) {
-          count++
-        }
-      }
-    }
-
- 
-    if (count > 0) {
-      let ports = await this.kernel.ports(count)
-      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) {
-        // local_share_ip :- 192.168....
-        let local_share_key = key.replace("PORT_PLACEHOLDER_", "")
-        let chunks = local_share_key.split(":")
-        let local_share_ip = chunks[0]
-        let original_port = chunks[1]
-        let local_share_port = replaced_map[key]
-        if (!this.local_network_mapping[local_share_ip]) {
-          this.local_network_mapping[local_share_ip] = {}
-        }
-        this.local_network_mapping[local_share_ip][original_port] = local_share_port
-
-
-        //let original_port = key.replace("PORT_PLACEHOLDER_", "")
-        this.port_mapping[original_port] = replaced_map[key]
-      }
-      this.port_cache = replaced_map
-    }
-
-
-
-
-
-    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