Simplify the env object to contain only: parsed_url, response, request, site

diff --git a/Site.js b/Site.js
index 4b49138..dbff5c3 100644 (file)
--- a/Site.js
+++ b/Site.js
@@ -26,15 +26,12 @@ let Site = function(root) {
   this.root = root
 }
 
-Site.prototype.app = async function(host, req, res, protocol) {
-  // parse the pathname portion of url
-  // this is actually cheating since it's not a complete url
-  let parsed_url = url.parse(req.url, true)
+Site.prototype.respond = async function(request, response, parsed_url) {
   let path = parsed_url.pathname.split('/')
 
   // path must begin with /
   if (path.length === 0 || path[0].length) {
-    server.die(res)
+    server.die(response)
     return
   }
 
@@ -44,8 +41,8 @@ Site.prototype.app = async function(host, req, res, protocol) {
   for (let i = 1; i < path.length - 1; ++i) {
     dir_name += '/' + path[i]
     if (path[i].length === 0 || path[i].charAt(0) === '.') {
-      console.log(host, 'bad path component', dir_name)
-      server.die(res)
+      console.log(parsed_url.host, 'bad path component', dir_name)
+      server.die(response)
       return
     }
     let stats
@@ -65,14 +62,14 @@ Site.prototype.app = async function(host, req, res, protocol) {
         catch (err2) {
           if (err2.code !== 'ENOENT')
             throw err2
-          console.log(host, 'directory not found', dir_name)
-          server.die(res)
+          console.log(parsed_url.host, 'directory not found', dir_name)
+          server.die(response)
           return
         }
       }
       if (!stats.isDirectory()) {
-        console.log(host, 'not directory', dir_name)
-        server.die(res)
+        console.log(parsed_url.host, 'not directory', dir_name)
+        server.die(response)
         return
       }
     }
@@ -82,8 +79,8 @@ Site.prototype.app = async function(host, req, res, protocol) {
   if (file_name === '') {
     path[path.length - 1] = 'index.html'
     path = path.join('/')
-    console.log(host, 'server.redirecting', parsed_url.pathname, 'to', path)
-    server.redirect(res, path + (parsed_url.search || ''))
+    console.log(parsed_url.host, 'server.redirecting', parsed_url.pathname, 'to', path)
+    server.redirect(response, path + (parsed_url.search || ''))
     return
   }
   let page = path.join('/')
@@ -100,14 +97,14 @@ Site.prototype.app = async function(host, req, res, protocol) {
     try {
       let data = await fs_readFile(temp)
       console.log(
-        host,
+        parsed_url.host,
         'serving',
         temp,
         'length',
         data.length,
         'from pub'
       )
-      server.serve(res, 200, mime_type, data)
+      server.serve(response, 200, mime_type, data)
       return
     }
     catch (err) {
@@ -122,14 +119,14 @@ Site.prototype.app = async function(host, req, res, protocol) {
     try {
       let data = await fs_readFile(this.root + temp)
       console.log(
-        host,
+        parsed_url.host,
         'serving',
         temp,
         'length',
         data.length,
         'from pub'
       )
-      server.serve(res, 200, mime_type, data)
+      server.serve(response, 200, mime_type, data)
       return
     }
     catch (err) {
@@ -153,40 +150,23 @@ Site.prototype.app = async function(host, req, res, protocol) {
         let _out = []
         await template(
           {
-            cookies: cookie.parse(req.headers.cookie || ''),
-            lang: 'en',
-            host: host,
-            method: req.method,
-            page: page,
-            query: parsed_url.query,
-            read_stream: req,
-            set_cookie: (key, value, expires, path) => {
-              res.setHeader(
-                'Set-Cookie',
-                key +
-                '=' +
-                value +
-                '; expires=' +
-                expires +
-                '; path=' +
-                path +
-                ';'
-              )
-            },
+            parsed_url: parsed_url,
+            response: response,
+            request: request,
             site: this
           },
           _out
         )
         let data = Buffer.from(_out.join(''))
         console.log(
-          host,
+          parsed_url.host,
           'serving',
           temp,
           'length',
           data.length,
           'from js'
         )
-        server.serve(res, 200, mime_type, data)
+        server.serve(response, 200, mime_type, data)
         return
       }
       break
@@ -196,14 +176,14 @@ Site.prototype.app = async function(host, req, res, protocol) {
       try {
         let data = await this.get_less(temp, dir_name)
         console.log(
-          host,
+          parsed_url.host,
           'serving',
           temp,
           'length',
           data.length,
           'from less'
         )
-        server.serve(res, 200, mime_type, data)
+        server.serve(response, 200, mime_type, data)
         return
       }
       catch (err) {
@@ -218,28 +198,28 @@ Site.prototype.app = async function(host, req, res, protocol) {
   if (Object.prototype.hasOwnProperty.call(favicons, page)) {
     let data = favicons[page]
     console.log(
-      host,
+      parsed_url.host,
       'serving',
       page,
       'length',
       data.length,
       'from favicons'
     )
-    server.serve(res, 200, mime_type, data)
+    server.serve(response, 200, mime_type, data)
     return
   }
 
-  console.log(host, 'file not found', page)
-  server.die(res)
+  console.log(parsed_url.host, 'file not found', page)
+  server.die(response)
 }
 
 Site.prototype.get_email = function(path) {
   path = this.root + path
   return resources.build_cache_email.get(
     path,
-    async result => {
+    async responseult => {
       console.log('getting', path, 'as email')
-      result.value = emailjs.server.connect(
+      responseult.value = emailjs.server.connect(
         JSON.parse(await fs_readFile(path))
       )
     }
@@ -252,9 +232,9 @@ Site.prototype.get_json = function(path) {
   path = this.root + path
   return resources.build_cache_json.get(
     path,
-    async result => {
+    async responseult => {
       console.log('getting', path, 'as json')
-      result.value = JSON.parse(await fs_readFile(path))
+      responseult.value = JSON.parse(await fs_readFile(path))
     }
   )
 }
@@ -263,13 +243,13 @@ Site.prototype.get_less = function(path, dir_name) {
   path = this.root + path
   return resources.build_cache_less.get(
     path,
-    async result => {
+    async responseult => {
       console.log('getting', path, 'as less')
       let render = await less.render(
         await fs_readFile(path, {encoding: 'utf-8'}),
         {
           //color: true,
-          //compress: false,
+          //compresponses: false,
           //depends: false,
           filename: path,
           //globalVars: null,
@@ -289,8 +269,8 @@ Site.prototype.get_less = function(path, dir_name) {
           //urlArgs: ''
         }
       )
-      result.deps.concat(render.imports)
-      result.value = Buffer.from(render.css)
+      responseult.deps.concat(render.imports)
+      responseult.value = Buffer.from(render.css)
     }
   )
 }
@@ -299,9 +279,9 @@ Site.prototype.get_text = function(path) {
   path = this.root + path
   return resources.build_cache_text.get(
     path,
-    async result => {
+    async responseult => {
       console.log('getting', path, 'as text')
-      result.value = await fs_readFile(path, {encoding: 'utf-8'})
+      responseult.value = await fs_readFile(path, {encoding: 'utf-8'})
     }
   )
 }
@@ -310,15 +290,15 @@ Site.prototype.get_zet = function(path) {
   path = this.root + path
   return resources.build_cache_zet.get(
     path,
-    async result => {
+    async responseult => {
       console.log('getting', path, 'as zet')
-      result.deps = [
+      responseult.deps = [
         path + '.map.0',
         path + '.param.0',
         path + '.v.0',
         path + '.vocab.0'
       ]
-      result.value = new zetjs.Index(path)
+      responseult.value = new zetjs.Index(path)
     }
   )
 }
@@ -327,36 +307,36 @@ Site.prototype.get_zip = function(path) {
   path = this.root + path
   return resources.build_cache_zip.get(
     path,
-    async result => {
+    async responseult => {
       console.log('getting', path, 'as zip')
-      result.value = {}
+      responseult.value = {}
       let zipfile = await yauzl_open(path, {autoClose: false})
       let entries = []
       await new Promise(
-        (resolve, reject) => {
+        (responseolve, reject) => {
           zipfile.
           on('entry', entry => {entries.push(entry)}).
-          on('end', () => resolve())
+          on('end', () => responseolve())
         }
       )
       for (let i = 0; i < entries.length; ++i) {
         let read_stream = await new Promise(
-          (resolve, reject) => {
+          (responseolve, reject) => {
             zipfile.openReadStream(
               entries[i],
               (err, stream) => {
                 if (err)
                   reject(err)
-                resolve(stream)
+                responseolve(stream)
               }
             )
           }
         )
         let write_stream = new stream_buffers.WritableStreamBuffer()
         let data = new Promise(
-          (resolve, reject) => {
+          (responseolve, reject) => {
             write_stream.
-            on('finish', () => {resolve(write_stream.getContents())}).
+            on('finish', () => {responseolve(write_stream.getContents())}).
             on('error', () => {reject()})
           }
         )
@@ -364,7 +344,7 @@ Site.prototype.get_zip = function(path) {
         let path = '/' + entries[i].fileName
         data = await data
         console.log('entry path', path, 'size', data.length)
-        result.value[path] = data
+        responseult.value[path] = data
       }
       await zipfile.close()
     }

diff --git a/jst_server.js b/jst_server.js
index 2dbd737..6078319 100755 (executable)
--- a/jst_server.js
+++ b/jst_server.js
@@ -30,7 +30,8 @@ commander.version('1.0.0').option(
 server.set_caching(commander.enableCaching)
 if (commander.httpPort !== -1) {
   http.createServer(
-    (req, res) => server.app(req, res, 'http') // ignore returned promise
+    (request, response) =>
+      server.respond(request, response, 'http:') // ignore returned promise
   ).listen(commander.httpPort)
   console.log('HTTP server listening on port', commander.httpPort)
 }
@@ -40,7 +41,8 @@ if (commander.httpsPort !== -1) {
       'cert': fs.readFileSync(commander.sslCert),
       'key': fs.readFileSync(commander.sslKey)
     },
-    (req, res) => server.app(req, res, 'https') // ignore returned promise
+    (request, response) =>
+      server.respond(request, response, 'https:') // ignore returned promise
   ).listen(commander.httpsPort)
   console.log('HTTPS server listening on port', commander.httpsPort)
 }

diff --git a/server.js b/server.js
index 0502ce9..e43b006 100644 (file)
--- a/server.js
+++ b/server.js
@@ -2,59 +2,61 @@ let Site = require('./Site')
 let assert = require('assert')
 let config = require('./config')
 let js_template = require('js_template')
+let url = require('url')
 
 let caching = false
 let set_caching = value => {
   caching = value
 }
 
-let serve = (res, status, mime_type, data) => {
-  res.statusCode = status
+let serve = (response, status, mime_type, data) => {
+  response.statusCode = status
   // html files will be direct recipient of links/bookmarks so can't have
   // a long lifetime, other files like css or images are often large files
   // and won't change frequently (but we'll need cache busting eventually)
   if (caching && mime_type !== config.mime_types_html)
-    res.setHeader('Cache-Control', 'max-age=3600')
-  res.setHeader('Content-Type', mime_type)
-  res.setHeader('Content-Length', data.length)
-  res.end(data)
+    response.setHeader('Cache-Control', 'max-age=3600')
+  response.setHeader('Content-Type', mime_type)
+  response.setHeader('Content-Length', data.length)
+  response.end(data)
 }
 
-let die = res => {
+let die = response => {
   let body = '<html><body>Page not found</body></html>'
-  serve(res, 404, config.mime_type_html, Buffer.from(body))
+  serve(response, 404, config.mime_type_html, Buffer.from(body))
 }
 
-let redirect = (res, location) => {
-  res.statusCode = 301
-  res.setHeader('Location', location)
-  res.end('Redirecting to ' + location)
+let redirect = (response, location) => {
+  response.statusCode = 301
+  response.setHeader('Location', location)
+  response.end('Redirecting to ' + location)
 }
 
 let site_cache = {}
 let site_factory_default = async root => new Site(root)
 
-let app = async (req, res, protocol) => {
-  await config.refresh()
+let respond = async (request, response, protocol) => {
   try {
-    let host = req.headers.host || 'localhost'
-    let temp = host.indexOf(':')
-    let port_suffix = temp === -1 ? '' : host.substring(temp)
-    host = host.substring(
-      0,
-      host.length - port_suffix.length
+    await config.refresh()
+    let parsed_url = url.parse(
+      protocol + '//' + (request.headers.host || 'localhost') + request.url,
+      true
     )
-    if (!Object.prototype.hasOwnProperty.call(config.sites, host)) {
-      console.log('nonexistent site', host)
-      die(res)
+    //console.log('parsed_url', parsed_url)
+
+    if (!Object.prototype.hasOwnProperty.call(config.sites, parsed_url.hostname)) {
+      console.log('nonexistent site', parsed_url.hostname)
+      die(response)
       return
     }
-    temp = config.sites[host]
+    let temp = config.sites[parsed_url.hostname]
     switch (temp.type) {
     case 'redirect':
-      let new_domain = temp.domain
-      console.log('redirecting', host, 'to', new_domain)
-      redirect(res, protocol + '://' + new_domain + port_suffix + req.url)
+      let hostname = temp.domain
+      if (parsed_url.port !== undefined)
+        hostname += ':' + parsed_url.port
+      console.log('redirecting', parsed_url.host, 'to', hostname)
+      redirect(response, parsed_url.protocol + '//' + hostname + request.url)
       break
     case 'site':
       let site_factory
@@ -81,7 +83,7 @@ let app = async (req, res, protocol) => {
         }
         site_cache[temp.root] = site
       }
-      await site.object.app(host, req, res, protocol)
+      await site.object.respond(request, response, parsed_url)
       break
     default:
       assert(false)
@@ -91,7 +93,7 @@ let app = async (req, res, protocol) => {
     let message = (err.stack || err.message).toString()
     console.error(message)
     let body = '<html><body><pre>' + message + '</pre></body></html>'
-    serve(res, 500, config.mime_type_html, Buffer.from(body, 'utf8'))
+    serve(response, 500, config.mime_type_html, Buffer.from(body, 'utf8'))
   }
 }
 
@@ -99,4 +101,4 @@ exports.set_caching = set_caching
 exports.serve = serve
 exports.die = die
 exports.redirect = redirect
-exports.app = app
+exports.respond = respond