Remove WebSocket server implementation and related functionality

backend/app.ts

@@ -6,7 +6,6 @@ import prisma from "./prisma"
 import server from "./server"
 import knex from "./services/knex"
 import { attachPrismaEvents } from "./util"
-import { wsListen } from "./wsServer"
 
 require("sharp") // image library sharp seems to crash without this require
 
@@ -40,8 +39,6 @@ const startApp = async () => {
     httpServer.listen(4000, () => {
       console.log("server running on port 4000")
     })
-
-    wsListen()
   }
 }
 

backend/bin/kafkaConsumer/common/userCourseProgress/saveToDB.ts

@@ -9,7 +9,6 @@ import {
 
 import { DatabaseInputError, TMCError } from "../../../../lib/errors"
 import { err, ok, parseTimestamp, Result } from "../../../../util"
-import { MessageType, pushMessageToClient } from "../../../../wsServer"
 import { getUserWithRaceCondition } from "../getUserWithRaceCondition"
 import { KafkaContext } from "../kafkaContext"
 import { generateUserCourseProgress } from "./generateUserCourseProgress"
@@ -152,11 +151,5 @@ export const saveToDatabase = async (
     context,
   })
 
-  await pushMessageToClient(
-    message.user_id,
-    message.course_id,
-    MessageType.PROGRESS_UPDATED,
-  )
-
   return ok("Saved to DB successfully")
 }

backend/bin/kafkaConsumer/common/userFunctions.ts

@@ -17,7 +17,6 @@ import {
   ensureDefinedArray,
   isNullish,
 } from "../../../util"
-import { MessageType, pushMessageToClient } from "../../../wsServer"
 import {
   ExerciseCompletionPart,
   ServiceProgressPartType,
@@ -346,11 +345,6 @@ export const createCompletion = async ({
     }
 
     // TODO: this only sends the completion email for the first tier completed
-    await pushMessageToClient(
-      user.upstream_id,
-      course.id,
-      MessageType.COURSE_CONFIRMED,
-    )
 
     if (course.completion_email_id) {
       await prisma.emailDelivery.create({

backend/services/redis.ts

@@ -1,14 +1,12 @@
 import parseJSON from "json-parse-even-better-errors"
-import { createClient, createSentinel } from "redis"
+import { createClient } from "redis"
 import * as winston from "winston"
 
 import {
   isTest,
   NEXUS_REFLECTION,
   REDIS_DB,
   REDIS_PASSWORD,
-  REDIS_SENTINEL_MASTER_NAME,
-  REDIS_SENTINELS,
   REDIS_URL,
 } from "../config"
 import { BaseContext } from "../context"
@@ -24,9 +22,7 @@ const _logger = winston.createLogger({
   transports: [new winston.transports.Console()],
 })
 
-type RedisClient =
-  | ReturnType<typeof createClient>
-  | ReturnType<typeof createSentinel>
+type RedisClient = ReturnType<typeof createClient>
 let redisClient: RedisClient | undefined
 let redisSubscriberClient: RedisClient | undefined
 
@@ -53,73 +49,34 @@ const getRedisClient = (): RedisClient | undefined => {
     return
   }
 
-  const useSentinel = REDIS_SENTINELS && REDIS_SENTINEL_MASTER_NAME
-
-  let client: RedisClient
-
-  if (useSentinel && REDIS_SENTINELS && REDIS_SENTINEL_MASTER_NAME) {
-    const sentinels = REDIS_SENTINELS.split(",").map((sentinel: string) => {
-      const [host, port] = sentinel.trim().split(":")
-      return { host, port: parseInt(port) ?? 26379 }
-    })
-
-    const sentinelClient = createSentinel({
-      name: REDIS_SENTINEL_MASTER_NAME,
-      sentinelRootNodes: sentinels,
-      nodeClientOptions: {
-        password: REDIS_PASSWORD,
-        database: REDIS_DB,
-        socket: {
-          reconnectStrategy: redisReconnectStrategy(),
-        },
-      },
-    })
-
-    sentinelClient.on("error", (err: any) => {
-      _logger.error(`Redis Sentinel error`, err)
-    })
-    sentinelClient.on("ready", () => {
-      _logger.info(
-        `Redis Sentinel connected to master: ${REDIS_SENTINEL_MASTER_NAME}`,
-      )
-    })
-
-    sentinelClient.connect().catch((err: any) => {
-      _logger.error(`Redis Sentinel connection failed`, err)
-    })
-
-    client = sentinelClient as RedisClient
-  } else {
-    let url = (REDIS_URL && REDIS_URL.trim()) || "redis://127.0.0.1:6379"
-    if (url && !url.startsWith("redis://") && !url.startsWith("rediss://")) {
-      url = `redis://${url}`
-    }
-    if (url && !url.includes(":") && !url.includes("/")) {
-      url = `${url}:6379`
-    }
-    const regularClient = createClient({
-      url,
-      password: REDIS_PASSWORD,
-      database: REDIS_DB,
-      socket: {
-        reconnectStrategy: redisReconnectStrategy(),
-      },
-    })
-
-    regularClient.on("error", (err: any) => {
-      _logger.error(`Redis error`, err)
-    })
-    regularClient.on("ready", () => {
-      _logger.info(`Redis connected to: ${url}`)
-    })
-
-    regularClient.connect().catch((err: any) => {
-      _logger.error(`Redis connection failed`, err)
-    })
-
-    client = regularClient as RedisClient
+  let url = (REDIS_URL && REDIS_URL.trim()) || "redis://127.0.0.1:6379"
+  if (url && !url.startsWith("redis://") && !url.startsWith("rediss://")) {
+    url = `redis://${url}`
+  }
+  if (url && !url.includes(":") && !url.includes("/")) {
+    url = `${url}:6379`
   }
 
+  const client = createClient({
+    url,
+    password: REDIS_PASSWORD,
+    database: REDIS_DB,
+    socket: {
+      reconnectStrategy: redisReconnectStrategy(),
+    },
+  })
+
+  client.on("error", (err: any) => {
+    _logger.error(`Redis error`, err)
+  })
+  client.on("ready", () => {
+    _logger.info(`Redis connected to: ${url}`)
+  })
+
+  client.connect().catch((err: any) => {
+    _logger.error(`Redis connection failed`, err)
+  })
+
   redisClient = client
   return client
 }
@@ -152,7 +109,7 @@ const getRedisSubscriberClient = (): RedisClient | undefined => {
     socket: {
       reconnectStrategy: redisReconnectStrategy("Redis Subscriber"),
     },
-  }) as RedisClient
+  })
 
   subscriber.on("error", (err: any) => {
     _logger.error(`Redis subscriber error`, err)
@@ -161,10 +118,6 @@ const getRedisSubscriberClient = (): RedisClient | undefined => {
     _logger.info(`Redis subscriber connected to: ${url}`)
   })
 
-  subscriber.connect().catch((err: any) => {
-    _logger.error(`Redis subscriber connection failed`, err)
-  })
-
   redisSubscriberClient = subscriber
   return redisSubscriberClient
 }