projects / henge / kiak.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
client done
[henge/kiak.git] / main.js
diff --git a/main.js b/main.js
index c7d5bd7..cdf8601 100644 (file)
--- a/main.js
+++ b/main.js
@@ -3,139 +3,131 @@
  * @author    Jordan Lavatai, Ken Grimes
  * @version   0.0.1
  * @license   AGPL-3.0
- * @copyright jk software 2017
+ * @copyright loljk 2017
  * @summary   HTTP(S) Router that uses the first directory in the requested URL
  *            as the route name
  */
 const fs = require('fs')
 const ws = require('ws')
+const path = require('path')
 const http = require('http')
 const https = require('https')
 const getport = require('get-port')
 const mime = require('mime')
 const opts = require('./opts.js')
 
-/* const routeConnection = (request,response) => {
-  const htArgv = request.url.slice(1).split("?")
-  let   routeName = /[^\/]*/.match(htArgv[0])[0]
-  if (routeName === '')
-    routeName = opts['index']
-  if (routeName.indexOf('.') != -1) {
-    if (routeName in fileBuf) {
-      response.writeHead(200, { 'Content-Type': fileBuf[routeName].mime })
-      response.write(fileBuf[routeName].data)
+const router = {
+  skelPage:   fs.readFileSync('./skel.html', { encoding: 'utf8' }).split('<!--STRAPP_SRC-->'),
+  clientJS:   fs.readFileSync(opts['client-js']),
+  hostJS:     fs.readFileSync(opts['host-js']),
+  routes:     {},
+  httpsOpt:   undefined,
+  httpd:      undefined,
+  wsProtocol: opts['no-tls'] ? 'ws' : 'wss',
+  respond:    (request,response) => {
+    const serveFile = (fPath) => {
+      fs.readFile(fPath, { encoding: 'utf8' }, (err, data) => {
+       if (err || data == undefined) {
+         response.writeHead(404)
+         response.end()
+       }
+       else {
+         response.writeHead(200, { 'Content-Type': mime.lookup(fPath) })
+         response.write(data)
+         response.end()
+       }
+      })
     }
-    else {
-      if ('404.html' in fileBuf) {
-       response.writeHead(404, fileBuf['404.html'].mime)
-       response.write(fileBuf['404.html'].data)
+    const htArgv = request.url.slice(1).split("?")
+    let routePath = htArgv[0].split('/')
+    let routeName = routePath[0]
+    if (routeName === '' || routeName === 'index.html')
+      serveFile(opts['index'])
+    else if (routeName in opts['bindings']) {
+      let localPath = path.normalize(opts['bindings'][routeName].concat(path.sep + routePath.slice(1).join(path.sep)))
+      if (localPath.includes(opts['bindings'][routeName])) {
+       fs.readdir(localPath, (err, files) => {
+         if (err)
+           serveFile(localPath)
+         else
+           serveFile(`${localPath}/index.html`)
+       })
+      }
+      else {
+       console.log(`SEC: ${localPath} references files not in route`)
       }
-      else
-       response.writeHead(404)
     }
-    response.end()
-  }
-  else if (routeName in routes) {
-    const route = routes[routeName]
-    response.writeHead(200, { 'Content-Type': 'text/html' })
-    response.write(skelPage[0] + clientJS + skelPage[1])
-    response.end()
-    route.socket.send(request.headers['x-forwarded-for'] || request.connection.remoteAddress)
-  }
-  else {
-    routes[htArgv[0]] = true
-    const newRoute = {}
-    newRoute.host = request.headers['x-forwarded-for'] || request.connection.remoteAddress
-    getport().then( (port) => {
-      newRoute.port = port
-      newRoute.httpd = https.createServer(routerOpts, (request, response) => {
-      }).listen(newRoute.port)
-      
-      newRoute.ws = new ws.Server( { server: newRoute.httpd } )
-      newRoute.ws.on('connection', (ws) => { console.log("socket connected"); newRoute.socket = ws; ws.send("CONNECTED") } )
-      newRoute.ws.on('message', (msg) => { console.log("Received message" + msg) })
-      console.log("Listening for websocket " + newRoute.host + " on port " + newRoute.port)
-      routes[htArgv[0]] = newRoute
-    }).then(() => {
+    else if (routeName in router.routes) {
+      const route = router.routes[routeName]
       response.writeHead(200, { 'Content-Type': 'text/html' })
-      response.write(skelPage[0] + 'const _strapp_port = \'' + newRoute.port + '\'\n' + hostJS + skelPage[1])
+      response.write(`${router.skelPage[0]}${router.clientJS}${router.skelPage[1]}`)
       response.end()
-    })
+      //TODO: if route.socket == undefined: have server delay this send until host connects
+      //      (this happens when a client connects to an active route with no currently-online host)
+      route.socket.send(request.headers['x-forwarded-for'] || request.connection.remoteAddress)
+    }
+    else {
+      router.routes[routeName] = true
+      const newRoute = {}
+      newRoute.host = request.headers['x-forwarded-for'] || request.connection.remoteAddress
+      getport().then( (port) => {
+       newRoute.port = port
+       if (opts['no-tls'])
+         newRoute.httpd = http.createServer()
+       else
+         newRoute.httpd = https.createServer(router.httpsOpts)
+       newRoute.httpd.listen(newRoute.port)
+       newRoute.wsd = new ws.Server( { server: newRoute.httpd } )
+       newRoute.wsd.on('connection', (sock) => {
+         newRoute.socket = sock
+         sock.on('message', (msg) => { console.log(`[${newRoute.host}] ${msg}`) })
+       })
+       console.log(`Listening for websocket ${newRoute.host} on port ${newRoute.port}`)
+       router.routes[routeName] = newRoute
+      }).then(() => {
+       response.writeHead(200, { 'Content-Type': 'text/html' })
+       response.write(`${router.skelPage[0]}` +
+                       `\tconst _strapp_port = ${newRoute.port}\n` + 
+                       `\tconst _strapp_protocol = '${router.wsProtocol}'\n` +
+                       `${router.hostJS}\n${router.skelPage[1]}`)
+       response.end()
+      })
+    }
+    
   }
 }
 
+/**
+ * @summary Boot up the router.  With TLS, we must wait for file reads to sync.
+ */
 if (!opts['no-tls']) {
-  router.httpd = http.createServer(router.listener)
-}
-else {
-  /* Setup TLS */
-  if (!fs.existsSync(opts['ca-key'])) {
-    console.log(`ERR: Key ${opts['ca-key']} inaccessible (required for tls)`)
-    process.exit()
-  }
-  if (!fs.existsSync(opts['ca-cert'])) {
-    console.log(`ERR: Cert ${opts['ca-cert']} inaccessible (required for tls)`)
-    process.exit()
-  }
-  router.opts = {
-    key: fs.readFileSync(opts['ca-key']),
-    cert: fs.readFileSync(opts['ca-cert'])
-  }
-}
-
-const skelPage = String(fs.readFileSync('skel.html')).split("<!--STRAPP_SRC-->")
-const clientJS = fs.readFileSync(opts['client-js'])
-const hostJS   = fs.readFileSync(opts['host-js'])
-const routes   = {}
-/*
-const router = https.createServer(routerOpts, (request, response) => {
-  const htArgv = request.url.slice(1).split("?")
-  let   routeName = htArgv[0].split('/')[0]
-  if (routeName === '')
-    routeName = 'index.html'
-  if (routeName.indexOf('.') != -1) {
-    if (routeName in fileBuf) {
-      response.writeHead(200, { 'Content-Type': fileBuf[routeName].mime })
-      response.write(fileBuf[routeName].data)
-    }
-    else {
-      if ('404.html' in fileBuf) {
-       response.writeHead(404, fileBuf['404.html'].mime)
-       response.write(fileBuf['404.html'].data)
+  let filesRead = 0
+  let key = undefined
+  let cert = undefined
+  const syncRead = () => {
+    if (++filesRead == 2) {
+      if (key == undefined)
+        console.log(`ERR: Key ${opts['ca-key']} inaccessible, tls will fail`)
+      if(cert == undefined)
+        console.log(`ERR: Cert ${opts['ca-cert']} inaccessible, tls will fail`)
+      else if (key != undefined) {
+        router.httpsOpts = { cert: cert, key: key}
+        router.httpd = https.createServer(router.httpsOpts, router.respond)
+          .listen(opts['port'])
       }
-      else
-       response.writeHead(404)
     }
-    response.end()
-  }
-  else if (routeName in routes) {
-    const route = routes[routeName]
-    response.writeHead(200, { 'Content-Type': 'text/html' })
-    response.write(skelPage[0] + clientJS + skelPage[1])
-    response.end()
-    route.socket.send(request.headers['x-forwarded-for'] || request.connection.remoteAddress)
   }
-  else {
-    routes[htArgv[0]] = true
-    const newRoute = {}
-    newRoute.host = request.headers['x-forwarded-for'] || request.connection.remoteAddress
-    getport().then( (port) => {
-      newRoute.port = port
-      newRoute.httpd = https.createServer(routerOpts, (request, response) => {
-      }).listen(newRoute.port)
-      
-      newRoute.ws = new ws.Server( { server: newRoute.httpd } )
-      newRoute.ws.on('connection', (ws) => { console.log("socket connected"); newRoute.socket = ws; ws.send("CONNECTED") } )
-      newRoute.ws.on('message', (msg) => { console.log("Received message" + msg) })
-      console.log("Listening for websocket " + newRoute.host + " on port " + newRoute.port)
-      routes[htArgv[0]] = newRoute
-    }).then(() => {
-      response.writeHead(200, { 'Content-Type': 'text/html' })
-      response.write(skelPage[0] + 'const _strapp_port = \'' + newRoute.port + '\'\n' + hostJS + skelPage[1])
-      response.end()
-    })
-  }
-}).listen(argv['port'])
-*/
+  fs.readFile(opts['ca-key'], { encoding: 'utf8' }, (err, data) => {
+    if (!err) key = data
+    syncRead()
+  })
+  fs.readFile(opts['ca-cert'], { encoding: 'utf8' }, (err, data) => {
+    if (!err) cert = data
+    syncRead()
+  })
+}
+else
+  router.httpd = http.createServer(router.respond).listen(opts['port'])
+
 //TODO: if ("electron" in process.versions) open a local renderwindow, and route to it
 
kiak isn't a kernel, it's a json-based filesystem that runs in browser memory and provides filesystem abstractions for general i/o, webrtc, webcrypto and webgl. it also provides a node.js server bridge over a websocket, providing restricted server-side filesystem access. the node.js server acts as a router, using URLs to route messages to the bridged 'remote admin', who then may receive HTTP and TCP connections in the browser. any application written for the kiak browser environment may also run on the node.js server. developed for the HENGE engine, but also an independent project providing a multi-user application framework (e.g. for multiplayer web games, screen sharing, or pair programming). the web-client is also a kiak routing server, so it can act as a host for its own clients, who may recursively act as servers for their own clients over WebRTC, and so on.