linter changes and refactored alive() to Heart

Author: Jacob Goldman

src/node/app/health.ts

@@ -6,38 +6,27 @@ import { HttpProvider, HttpResponse, Route, Heart, HttpProviderOptions } from ".
  * Check the heartbeat.
  */
 export class HealthHttpProvider extends HttpProvider {
+  public constructor(options: HttpProviderOptions, private readonly heart: Heart) {
+    super(options)
+  }
 
-    public constructor(
-        options: HttpProviderOptions,
-        private readonly heart: Heart
-      ) {
-        super(options)
+  public async handleRequest(route: Route, request: http.IncomingMessage): Promise<HttpResponse> {
+    if (!this.authenticated(request)) {
+      if (this.isRoot(route)) {
+        return { redirect: "/login", query: { to: route.fullPath } }
+      }
+      throw new HttpError("Unauthorized", HttpCode.Unauthorized)
     }
 
-    private alive(): Boolean {
-        const now = Date.now()
-        return (now - this.heart.lastHeartbeat < this.heart.heartbeatInterval)
+    const result = {
+      cache: false,
+      mime: "application/json",
+      content: {
+        status: this.heart.alive() ? "alive" : "expired",
+        lastHeartbeat: this.heart.lastHeartbeat,
+      },
     }
 
-    public async handleRequest(route: Route, request: http.IncomingMessage): Promise<HttpResponse> {
-        if (!this.authenticated(request)) {
-            if (this.isRoot(route)) {
-            return { redirect: "/login", query: { to: route.fullPath } }
-            }
-            throw new HttpError("Unauthorized", HttpCode.Unauthorized)
-        }
-
-        const result = {
-            cache: false,
-            mime: 'application/json',
-            content: {
-                status: (this.alive()) ? 'alive' : 'expired',
-                lastHeartbeat: this.heart.lastHeartbeat
-
-            }
-        }
-
-        return result
-        
-    }
+    return result
+  }
 }

src/node/entry.ts

@@ -2,18 +2,18 @@ import { field, logger } from "@coder/logger"
 import * as cp from "child_process"
 import * as path from "path"
 import { CliMessage } from "../../lib/vscode/src/vs/server/ipc"
+import { plural } from "../common/util"
+import { HealthHttpProvider } from "./app/health"
 import { LoginHttpProvider } from "./app/login"
 import { ProxyHttpProvider } from "./app/proxy"
 import { StaticHttpProvider } from "./app/static"
 import { UpdateHttpProvider } from "./app/update"
 import { VscodeHttpProvider } from "./app/vscode"
-import { HealthHttpProvider } from "./app/health"
 import { Args, bindAddrFromAllSources, optionDescriptions, parse, readConfigFile, setDefaults } from "./cli"
 import { AuthType, HttpServer, HttpServerOptions } from "./http"
 import { loadPlugins } from "./plugin"
 import { generateCertificate, hash, humanPath, open } from "./util"
 import { ipcMain, wrap } from "./wrapper"
-import { plural } from "../common/util"
 
 process.on("uncaughtException", (error) => {
   logger.error(`Uncaught exception: ${error.message}`)

src/node/http.ts

@@ -395,24 +395,27 @@ export abstract class HttpProvider {
  */
 export class Heart {
   private heartbeatTimer?: NodeJS.Timeout
-  public heartbeatInterval = 60000
+  private heartbeatInterval = 60000
   public lastHeartbeat = 0
 
   public constructor(private readonly heartbeatPath: string, private readonly isActive: () => Promise<boolean>) {}
 
+  public alive(): boolean {
+    const now = Date.now()
+    return now - this.lastHeartbeat < this.heartbeatInterval
+  }
   /**
    * Write to the heartbeat file if we haven't already done so within the
    * timeout and start or reset a timer that keeps running as long as there is
    * activity. Failures are logged as warnings.
    */
   public beat(): void {
-    const now = Date.now()
-    if (now - this.lastHeartbeat >= this.heartbeatInterval) {
+    if (!this.alive()) {
       logger.trace("heartbeat")
       fs.outputFile(this.heartbeatPath, "").catch((error) => {
         logger.warn(error.message)
       })
-      this.lastHeartbeat = now
+      this.lastHeartbeat = Date.now()
       if (typeof this.heartbeatTimer !== "undefined") {
         clearTimeout(this.heartbeatTimer)
       }
@@ -603,8 +606,9 @@ export class HttpServer {
 
   private onRequest = async (request: http.IncomingMessage, response: http.ServerResponse): Promise<void> => {
     const route = this.parseUrl(request)
-    if (route.providerBase !== '/healthz')
-      this.heart.beat()      
+    if (route.providerBase !== "/healthz") {
+      this.heart.beat()
+    }
     const write = (payload: HttpResponse): void => {
       response.writeHead(payload.redirect ? HttpCode.Redirect : payload.code || HttpCode.Ok, {
         "Content-Type": payload.mime || getMediaMime(payload.filePath),