bare-http1 4.3.1 → 4.4.0

package/lib/agent.js

@@ -66,12 +66,13 @@ class HTTPAgent extends EventEmitter {
   constructor(opts = {}) {
     super()
 
-    const { keepAlive = false, keepAliveMsecs = 1000 } = opts
+    const { keepAlive = false, keepAliveMsecs = 1000, defaultPort = 80 } = opts
 
     this._sockets = new HTTPSocketSet()
     this._freeSockets = new HTTPSocketSet()
 
     this._keepAlive = typeof keepAlive === 'number' ? keepAlive : keepAlive ? keepAliveMsecs : -1
+    this._defaultPort = defaultPort
 
     this._opts = { ...opts }
   }
@@ -84,6 +85,10 @@ class HTTPAgent extends EventEmitter {
     return this._freeSockets.sockets()
   }
 
+  get defaultPort() {
+    return this._defaultPort
+  }
+
   createConnection(opts) {
     return tcp.createConnection(opts)
   }
@@ -120,10 +125,10 @@ class HTTPAgent extends EventEmitter {
 
       socket
         .on('free', onfree)
-        .on('timeout', ontimeout)
         .on('end', onremove)
         .on('finish', onremove)
         .on('close', onremove)
+        .on('timeout', ontimeout)
 
       function onfree() {
         if (socket.destroyed) return
@@ -137,12 +142,6 @@ class HTTPAgent extends EventEmitter {
         agent.emit('free', socket)
       }
 
-      function ontimeout() {
-        socket.destroy()
-
-        agent._freeSockets.delete(name, socket)
-      }
-
       function onremove() {
         socket.off('free', onfree)
 
@@ -151,30 +150,31 @@ class HTTPAgent extends EventEmitter {
 
         if (agent._sockets.size === 0) HTTPAgent._agents.delete(agent)
       }
+
+      function ontimeout() {
+        socket.destroy()
+
+        agent._freeSockets.delete(name, socket)
+      }
     }
 
     if (this._sockets.size === 0) HTTPAgent._agents.add(this)
 
     this._sockets.add(name, socket)
 
-    req.socket = socket
+    req._socket = socket
 
     const connection = HTTPClientConnection.from(socket, opts)
 
-    connection.req = req
+    connection._req = req
   }
 
   destroy() {
     for (const socket of this._sockets.sockets()) socket.destroy()
   }
 
-  static _global = new this({ keepAlive: 1000, timeout: 5000 })
   static _agents = new Set()
 
-  static get global() {
-    return this._global
-  }
-
   static _onidle() {
     for (const agent of this._agents) {
       for (const socket of agent._sockets.sockets()) socket.destroy()
@@ -182,6 +182,8 @@ class HTTPAgent extends EventEmitter {
   }
 }
 
+HTTPAgent.global = new HTTPAgent({ keepAlive: 1000, timeout: 5000 })
+
 module.exports = HTTPAgent
 
 Bare.on('idle', HTTPAgent._onidle.bind(HTTPAgent))

package/lib/client-connection.js

@@ -22,10 +22,10 @@ module.exports = class HTTPClientConnection {
   constructor(socket, opts = {}) {
     const { IncomingMessage = HTTPIncomingMessage } = opts
 
-    this.socket = socket
+    this._socket = socket
 
-    this.req = null
-    this.res = null
+    this._req = null
+    this._res = null
 
     this._IncomingMessage = IncomingMessage
 
@@ -50,20 +50,32 @@ module.exports = class HTTPClientConnection {
     HTTPClientConnection._connections.set(socket, this)
   }
 
+  get socket() {
+    return this._socket
+  }
+
+  get req() {
+    return this._req
+  }
+
+  get res() {
+    return this._res
+  }
+
   get idle() {
     return this._idle
   }
 
   _onerror(err) {
-    if (this.req) this.req.destroy(err)
+    if (this._req) this._req.destroy(err)
   }
 
   _onclose() {
-    if (this.req) this.req._continueFinal()
+    if (this._req) this._req._continueFinal()
   }
 
   _onend() {
-    if (this.req) this.req.destroy(errors.CONNECTION_LOST())
+    if (this._req) this._req.destroy(errors.CONNECTION_LOST())
   }
 
   _ondata(data) {
@@ -73,68 +85,70 @@ module.exports = class HTTPClientConnection {
       for (const op of this._parser.push(data)) {
         switch (op.type) {
           case RESPONSE:
-            this.req.on('close', () => {
-              this.req = null
+            this._req.on('close', () => {
+              this._req = null
             })
 
-            this.res = new this._IncomingMessage(this.socket, op.headers, {
+            this._res = new this._IncomingMessage(this._socket, op.headers, {
               statusCode: op.code,
               statusMessage: op.reason
             })
 
-            this.res.on('close', () => {
-              this.res = null
-
+            this._res.on('close', () => {
+              this._res = null
               this._idle = true
 
-              this.socket.emit('free')
+              this._socket.emit('free')
             })
 
             if (op.headers.connection && op.headers.connection.toLowerCase() === 'upgrade') {
               return this._onupgrade(this._parser.end())
             }
 
-            this.req.emit('response', this.res)
+            this._req.emit('response', this._res)
             break
 
           case DATA:
-            this.res.push(op.data)
+            this._res.push(op.data)
             break
 
           case END:
-            if (this.res) this.res.push(null)
-            if (this.req) this.req._continueFinal()
+            if (this._res) this._res.push(null)
+            if (this._req) this._req._continueFinal()
             break
         }
       }
     } catch (err) {
-      this.socket.destroy(err)
+      this._socket.destroy(err)
     }
   }
 
   _onupgrade(data) {
-    this._ondetach()
+    this._detach()
+
+    const res = this._res
+    const req = this._req
 
-    const req = this.req
+    res._upgrade = req._upgrade = true
 
-    req.upgrade = true
-    req.destroy()
+    const upgraded = req.emit('upgrade', res, this._socket, data || EMPTY)
 
-    if (req.emit('upgrade', this.res, this.socket, data || EMPTY)) return
+    res.push(null)
+    req._continueFinal()
 
-    this.socket.destroy()
+    if (!upgraded) this._socket.destroy()
   }
 
   _ontimeout() {
-    if (this.req) this.req.emit('timeout')
+    if (this._req) this._req.emit('timeout')
   }
 
   _ondrain() {
-    if (this.req) this.req._continueWrite()
+    if (this._req) this._req._continueWrite()
   }
 
-  _ondetach() {
-    this.socket
+  _detach() {
+    this._socket
       .off('error', this._onerror)
       .off('close', this._onclose)
       .off('end', this._onend)
@@ -142,6 +156,6 @@ module.exports = class HTTPClientConnection {
       .off('drain', this._ondrain)
       .off('timeout', this._ontimeout)
 
-    HTTPClientConnection._connections.delete(this.socket)
+    HTTPClientConnection._connections.delete(this._socket)
   }
 }

package/lib/client-request.js

@@ -16,38 +16,48 @@ module.exports = class HTTPClientRequest extends HTTPOutgoingMessage {
     const agent = opts.agent === false ? new HTTPAgent() : opts.agent || HTTPAgent.global
     const method = opts.method || 'GET'
     const path = opts.path || '/'
+    const defaultPort = opts.defaultPort || (agent && agent.defaultPort) || 80
     const host = (opts.host = opts.host || 'localhost')
-    const port = (opts.port = opts.port || 80)
-    const headers = { host: host + (port === 80 ? '' : ':' + port), ...opts.headers }
+    const port = (opts.port = opts.port || defaultPort)
+    const headers = { host: hostHeader(host, port, defaultPort), ...opts.headers }
 
     super()
 
     agent.addRequest(this, opts)
 
-    this.method = method
-    this.path = path
-    this.headers = headers
+    this._headers = headers
+    this._method = method
+    this._path = path
 
     this._chunked = method !== 'GET' && method !== 'HEAD'
 
+    this._pendingWrite = null
     this._pendingFinal = null
 
     if (onresponse) this.once('response', onresponse)
   }
 
+  get method() {
+    return this._method
+  }
+
+  get path() {
+    return this._path
+  }
+
   // For Node.js compatibility
   abort() {
     return this.destroy()
   }
 
   _header() {
-    let h = `${this.method} ${this.path} HTTP/1.1\r\n`
+    let h = `${this._method} ${this._path} HTTP/1.1\r\n`
 
     let upgrade = false
 
-    for (const name of Object.keys(this.headers)) {
+    for (const name of Object.keys(this._headers)) {
       const n = name.toLowerCase()
-      const v = this.headers[name]
+      const v = this._headers[name]
 
       if (n === 'content-length') this._chunked = false
       if (n === 'connection' && v && v.toLowerCase() === 'upgrade') upgrade = true
@@ -65,33 +75,34 @@ module.exports = class HTTPClientRequest extends HTTPOutgoingMessage {
   }
 
   _write(data, encoding, cb) {
-    if (this.headersSent === false) this.flushHeaders()
+    if (this._headersSent === false) this.flushHeaders()
 
     if (this._chunked) {
-      this.socket.write(Buffer.from(data.byteLength.toString(16)))
-      this.socket.write(CHUNK_DELIMITER)
+      this._socket.write(Buffer.from(data.byteLength.toString(16)))
+      this._socket.write(CHUNK_DELIMITER)
     }
 
-    let flushed = this.socket.write(data)
+    let flushed = this._socket.write(data)
 
-    if (this._chunked) flushed = this.socket.write(CHUNK_DELIMITER)
+    if (this._chunked) flushed = this._socket.write(CHUNK_DELIMITER)
 
     if (flushed) cb(null)
     else this._pendingWrite = cb
   }
 
   _final(cb) {
-    if (this.headersSent === false) this.flushHeaders()
+    if (this._headersSent === false) this.flushHeaders()
 
-    if (this._chunked) this.socket.write(CHUNK_TERMINATOR)
+    if (this._chunked) this._socket.write(CHUNK_TERMINATOR)
 
     this._pendingFinal = cb
   }
 
   _predestroy() {
-    if (this.upgrade) return this._continueFinal()
+    super._predestroy()
 
-    this.socket.destroy()
+    this._continueWrite()
+    this._continueFinal()
   }
 
   _continueWrite() {
@@ -116,3 +127,17 @@ function httpCase(n) {
   }
   return s
 }
+
+function hostHeader(host, port, defaultPort) {
+  const i = host.indexOf(':')
+
+  if (i !== -1 && host.includes(':', i + 1) && host.charCodeAt(0) !== 91 /* [ */) {
+    host = `[${host}]`
+  }
+
+  if (port && +port !== defaultPort) {
+    host += ':' + port
+  }
+
+  return host
+}

package/lib/incoming-message.js

@@ -4,17 +4,45 @@ module.exports = class HTTPIncomingMessage extends Readable {
   constructor(socket = null, headers = {}, opts = {}) {
     super()
 
-    this.socket = socket
-    this.headers = headers
-    this.upgrade = false
+    this._socket = socket
+    this._headers = headers
+    this._upgrade = false
 
     // Server options
-    this.method = opts.method || ''
-    this.url = opts.url || ''
+    this._method = opts.method || ''
+    this._url = opts.url || ''
 
     // Client options
-    this.statusCode = opts.statusCode || 0
-    this.statusMessage = opts.statusMessage || ''
+    this._statusCode = opts.statusCode || 0
+    this._statusMessage = opts.statusMessage || ''
+  }
+
+  get socket() {
+    return this._socket
+  }
+
+  get headers() {
+    return this._headers
+  }
+
+  get upgrade() {
+    return this._upgrade
+  }
+
+  get method() {
+    return this._method
+  }
+
+  get url() {
+    return this._url
+  }
+
+  get statusCode() {
+    return this._statusCode
+  }
+
+  get statusMessage() {
+    return this._statusMessage
   }
 
   get httpVersion() {
@@ -22,26 +50,26 @@ module.exports = class HTTPIncomingMessage extends Readable {
   }
 
   getHeader(name) {
-    return this.headers[name.toLowerCase()]
+    return this._headers[name.toLowerCase()]
   }
 
   getHeaders() {
-    return { ...this.headers }
+    return { ...this._headers }
   }
 
   hasHeader(name) {
-    return name.toLowerCase() in this.headers
+    return name.toLowerCase() in this._headers
   }
 
   setTimeout(ms, ontimeout) {
     if (ontimeout) this.once('timeout', ontimeout)
 
-    this.socket.setTimeout(ms)
+    this._socket.setTimeout(ms)
 
     return this
   }
 
   _predestroy() {
-    if (this.upgrade === false && this.socket !== null) this.socket.destroy()
+    if (this._upgrade === false && this._socket !== null) this._socket.destroy()
   }
 }

package/lib/outgoing-message.js

@@ -5,39 +5,55 @@ module.exports = class HTTPOutgoingMessage extends Writable {
   constructor(socket = null) {
     super()
 
-    this.socket = socket
-    this.headers = {}
-    this.headersSent = false
-    this.upgrade = false
+    this._socket = socket
+    this._headers = {}
+    this._headersSent = false
+    this._upgrade = false
+  }
+
+  get socket() {
+    return this._socket
+  }
+
+  get headers() {
+    return this._headers
+  }
+
+  get headersSent() {
+    return this._headersSent
+  }
+
+  get upgrade() {
+    return this._upgrade
   }
 
   getHeader(name) {
-    return this.headers[name.toLowerCase()]
+    return this._headers[name.toLowerCase()]
   }
 
   getHeaders() {
-    return { ...this.headers }
+    return { ...this._headers }
   }
 
   hasHeader(name) {
-    return name.toLowerCase() in this.headers
+    return name.toLowerCase() in this._headers
   }
 
   setHeader(name, value) {
-    this.headers[name.toLowerCase()] = value
+    this._headers[name.toLowerCase()] = value
   }
 
   flushHeaders() {
-    if (this.headersSent === true || this.socket === null) return
+    if (this._headersSent === true || this._socket === null) return
 
-    this.socket.write(Buffer.from(this._header()))
-    this.headersSent = true
+    this._socket.write(Buffer.from(this._header()))
+    this._headersSent = true
   }
 
   setTimeout(ms, ontimeout) {
     if (ontimeout) this.once('timeout', ontimeout)
 
-    this.socket.setTimeout(ms)
+    this._socket.setTimeout(ms)
 
     return this
   }
@@ -47,6 +63,6 @@ module.exports = class HTTPOutgoingMessage extends Writable {
   }
 
   _predestroy() {
-    if (this.upgrade === false && this.socket !== null) this.socket.destroy()
+    if (this._upgrade === false && this._socket !== null) this._socket.destroy()
   }
 }

package/lib/server-connection.js

@@ -19,11 +19,11 @@ module.exports = class HTTPServerConnection {
   constructor(server, socket, opts = {}) {
     const { IncomingMessage = HTTPIncomingMessage, ServerResponse = HTTPServerResponse } = opts
 
-    this.server = server
-    this.socket = socket
+    this._server = server
+    this._socket = socket
 
-    this.req = null
-    this.res = null
+    this._req = null
+    this._res = null
 
     this._IncomingMessage = IncomingMessage
     this._ServerResponse = ServerResponse
@@ -45,7 +45,23 @@ module.exports = class HTTPServerConnection {
 
     HTTPServerConnection._connections.set(socket, this)
 
-    if (this.server.timeout) socket.setTimeout(this.server.timeout)
+    if (this._server.timeout) socket.setTimeout(this._server.timeout)
+  }
+
+  get server() {
+    return this._server
+  }
+
+  get socket() {
+    return this._socket
+  }
+
+  get req() {
+    return this._req
+  }
+
+  get res() {
+    return this._res
   }
 
   get idle() {
@@ -53,10 +69,10 @@ module.exports = class HTTPServerConnection {
   }
 
   _onclose() {
-    if (this.req && !isEnded(this.req)) this.req.destroy()
-    if (this.res && !isFinished(this.res)) this.res.destroy()
-    const err = getStreamError(this.socket)
-    if (err) this.socket.destroy(err)
+    if (this._req && !isEnded(this._req)) this._req.destroy()
+    if (this._res && !isFinished(this._res)) this._res.destroy()
+    const err = getStreamError(this._socket)
+    if (err) this._socket.destroy(err)
   }
 
   _ondata(data) {
@@ -66,86 +82,89 @@ module.exports = class HTTPServerConnection {
       for (const op of this._parser.push(data)) {
         switch (op.type) {
           case REQUEST:
-            this.req = new this._IncomingMessage(this.socket, op.headers, {
+            this._req = new this._IncomingMessage(this._socket, op.headers, {
               method: op.method,
               url: op.url
             })
 
-            this.req.on('close', () => {
-              this.req = null
+            this._req.on('close', () => {
+              this._req = null
 
               this._idle = true
 
-              if (this.server.closing) this.socket.destroy()
+              if (this._server.closing) this._socket.destroy()
             })
 
             // Eagerly open the request stream
-            this.req.resume()
-            this.req.pause()
+            this._req.resume()
+            this._req.pause()
 
             if (op.headers.connection && op.headers.connection.toLowerCase() === 'upgrade') {
               return this._onupgrade(this._parser.end())
             }
 
-            this.res = new this._ServerResponse(
-              this.socket,
-              this.req,
+            this._res = new this._ServerResponse(
+              this._socket,
+              this._req,
               op.headers.connection === 'close'
             )
 
-            this.res.on('close', () => {
-              this.res = null
+            this._res.on('close', () => {
+              this._res = null
             })
 
-            this.server.emit('request', this.req, this.res)
+            this._server.emit('request', this._req, this._res)
             break
 
           case DATA:
-            this.req.push(op.data)
+            this._req.push(op.data)
             break
 
           case END:
-            if (this.req) this.req.push(null)
+            if (this._req) this._req.push(null)
             break
         }
       }
     } catch (err) {
-      this.socket.destroy(err)
+      this._socket.destroy(err)
     }
   }
 
   _onupgrade(data) {
-    this._ondetach()
+    this._detach()
+
+    const req = this._req
+
+    req._upgrade = true
 
-    const req = this.req
+    const upgraded = this._server.emit('upgrade', req, this._socket, data || EMPTY)
 
-    req.upgrade = true
-    req.destroy()
+    req.push(null)
 
-    this.server.emit('upgrade', req, this.socket, data || EMPTY)
+    if (!upgraded) this._socket.destroy()
   }
 
   _ontimeout() {
-    const reqTimeout = this.req && this.req.emit('timeout')
-    const resTimeout = this.res && this.res.emit('timeout')
-    const serverTimeout = this.server.emit('timeout', this.socket)
+    const reqTimeout = this._req && this._req.emit('timeout')
+    const resTimeout = this._res && this._res.emit('timeout')
+    const serverTimeout = this._server.emit('timeout', this._socket)
 
-    if (!reqTimeout && !resTimeout && !serverTimeout) this.socket.destroy()
+    if (!reqTimeout && !resTimeout && !serverTimeout) this._socket.destroy()
   }
 
   _ondrain() {
-    if (this.res) this.res._continueWrite()
+    if (this._res) this._res._continueWrite()
   }
 
-  _ondetach() {
-    this.socket
+  _detach() {
+    this._socket
       .off('error', noop)
       .off('close', this._onclose)
       .off('data', this._ondata)
       .off('drain', this._ondrain)
       .off('timeout', this._ontimeout)
 
-    HTTPServerConnection._connections.delete(this.socket)
+    HTTPServerConnection._connections.delete(this._socket)
   }
 }
 

package/lib/server-response.js

@@ -8,10 +8,10 @@ module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
   constructor(socket, req, close) {
     super(socket)
 
-    this.req = req
+    this._req = req
 
-    this.statusCode = 200
-    this.statusMessage = null
+    this._statusCode = 200
+    this._statusMessage = null
 
     this._chunked = true
     this._close = close
@@ -21,8 +21,21 @@ module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
     this._pendingWrite = null
   }
 
+  get req() {
+    return this._req
+  }
+
+  get statusCode() {
+    return this._statusCode
+  }
+
+  get statusMessage() {
+    return this._statusMessage
+  }
+
   end(data) {
     this._finishing = true
+
     return super.end(data)
   }
 
@@ -32,22 +45,23 @@ module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
       statusMessage = null
     }
 
-    this.statusCode = statusCode
-    this.statusMessage = statusMessage || null
-    if (headers) this.headers = { ...this.headers, ...headers }
+    this._statusCode = statusCode
+    this._statusMessage = statusMessage || null
+
+    if (headers) this._headers = { ...this._headers, ...headers }
   }
 
   _header() {
     let h =
       'HTTP/1.1 ' +
-      this.statusCode +
+      this._statusCode +
       ' ' +
-      (this.statusMessage === null ? constants.status[this.statusCode] : this.statusMessage) +
+      (this._statusMessage === null ? constants.status[this._statusCode] : this._statusMessage) +
       '\r\n'
 
-    for (const name of Object.keys(this.headers)) {
+    for (const name of Object.keys(this._headers)) {
       const n = name.toLowerCase()
-      const v = this.headers[name]
+      const v = this._headers[name]
 
       if (n === 'content-length') this._chunked = false
       if (n === 'connection' && v && v.toLowerCase() === 'close') this._close = true
@@ -63,7 +77,7 @@ module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
   }
 
   _write(data, encoding, cb) {
-    if (this.headersSent === false) {
+    if (this._headersSent === false) {
       if (this._finishing) {
         this.setHeader(
           'Content-Length',
@@ -77,36 +91,37 @@ module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
     if (this._onlyHeaders === true) return cb(null)
 
     if (this._chunked) {
-      this.socket.write(Buffer.from(data.byteLength.toString(16)))
-      this.socket.write(CHUNK_DELIMITER)
+      this._socket.write(Buffer.from(data.byteLength.toString(16)))
+      this._socket.write(CHUNK_DELIMITER)
     }
 
-    let flushed = this.socket.write(data)
+    let flushed = this._socket.write(data)
 
-    if (this._chunked) flushed = this.socket.write(CHUNK_DELIMITER)
+    if (this._chunked) flushed = this._socket.write(CHUNK_DELIMITER)
 
     if (flushed) cb(null)
     else this._pendingWrite = cb
   }
 
   _final(cb) {
-    if (this.headersSent === false) {
+    if (this._headersSent === false) {
       this.setHeader('Content-Length', '0')
       this.flushHeaders()
     }
 
     if (this._chunked && this._onlyHeaders === false) {
-      this.socket.write(CHUNK_TERMINATOR)
+      this._socket.write(CHUNK_TERMINATOR)
     }
 
-    if (this._close) this.socket.end()
+    if (this._close) this._socket.end()
 
     cb(null)
   }
 
   _predestroy() {
     super._predestroy()
-    this.req.destroy()
+
+    this._req.destroy()
     this._continueWrite()
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-http1",
-  "version": "4.3.1",
+  "version": "4.4.0",
   "description": "Native HTTP/1 library for JavaScript",
   "exports": {
     "./package": "./package.json",