first commit

.env

@@ -0,0 +1,2 @@
+PORT=5003
+MONGO_URI=mongodb://root:p62Z!ZatgY25@194.26.138.94:27017

.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

ecosystem.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  apps: [
+    {
+      name: "stream.graff.tech-socket:5003",
+      exec_mode: "cluster",
+      script: "yarn",
+      args: "start",
+    },
+  ],
+};

package.json

@@ -0,0 +1,25 @@
+{
+  "name": "server",
+  "private": true,
+  "version": "0.0.0",
+  "scripts": {
+    "dev": "nodemon src/index.ts",
+    "build": "npx tsc",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "dotenv": "^16.3.1",
+    "express": "^4.19.2",
+    "mongoose": "^8.2.2",
+    "socket.io": "^4.7.4"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/mongoose": "^5.11.97",
+    "@types/node": "^20.8.10",
+    "@types/nodemailer": "^6.4.14",
+    "nodemon": "^3.0.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
+  }
+}

src/config/db.ts

@@ -0,0 +1,16 @@
+import { connect } from "mongoose";
+
+async function connectDB() {
+  try {
+    await connect(process.env.MONGO_URI!, { dbName: "pixel_streaming2" });
+    console.log("MongoDB connected...");
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error.message);
+    }
+
+    process.exit(1);
+  }
+}
+
+export default connectDB;

src/index.ts

@@ -0,0 +1,102 @@
+import "dotenv/config";
+import express from "express";
+import { createServer } from "http";
+import { Server } from "socket.io";
+import ActiveSession from "./models/ActiveSession";
+import connectDB from "./config/db";
+
+connectDB();
+
+const app = express();
+const port = process.env.PORT || 3000;
+const server = createServer(app);
+const io = new Server(server, {
+  cors: {
+    origin: "*",
+  },
+});
+
+io.on("connection", async (socket) => {
+  const { roomId, user } = socket.handshake.auth;
+
+  user.ownerIp = socket.handshake.headers["x-real-ip"];
+
+  let activeSession;
+
+  try {
+    activeSession = await ActiveSession.findById(roomId);
+  } catch (error) {
+    console.log((error as Error).message);
+  }
+
+  if (activeSession?.ownerIp === user.ownerIp || user.superAdmin) {
+    user.isAdmin = true;
+    user.isControlAllowed = true;
+  } else {
+    user.isAdmin = false;
+    user.isControlAllowed = false;
+  }
+
+  // console.log("socket.conn.remoteAddress", socket.conn.remoteAddress);
+  // console.log("socket.handshake.address", socket.handshake.address);
+
+  socket.join(roomId);
+
+  const sockets = await io.in(roomId).fetchSockets();
+
+  io.to(roomId).emit(
+    "update",
+    sockets.map((socket) => socket.handshake.auth.user)
+  );
+
+  try {
+    await ActiveSession.findByIdAndUpdate(roomId, {
+      connectedPlayersCount: sockets.length,
+    });
+  } catch (error) {}
+
+  socket.on("request-control", async (userId) => {
+    io.to(roomId).emit(
+      "request-control",
+      sockets.find((socket) => socket.handshake.auth.user.id === userId)
+        ?.handshake.auth.user.id
+    );
+  });
+
+  socket.on("transfer-control", async (userId) => {
+    const sockets = await io.in(roomId).fetchSockets();
+
+    const roomUsers = sockets.map((socket) => socket.handshake.auth.user);
+    const updatedRoomUsers = roomUsers.map((roomUser) => {
+      if (roomUser.id === userId) {
+        io.to(roomId).emit("transfer-control", userId);
+        roomUser.isControlAllowed = true;
+      } else {
+        roomUser.isControlAllowed = false;
+      }
+
+      return roomUser;
+    });
+
+    io.to(roomId).emit("update", updatedRoomUsers);
+  });
+
+  socket.on("disconnect", async () => {
+    const sockets = await io.in(roomId).fetchSockets();
+
+    io.to(roomId).emit(
+      "update",
+      sockets.map((socket) => socket.handshake.auth.user)
+    );
+
+    try {
+      await ActiveSession.findByIdAndUpdate(roomId, {
+        connectedPlayersCount: sockets.length,
+      });
+    } catch (error) {}
+  });
+});
+
+server.listen(port, () => {
+  console.log(`Server is listening on port ${port}`);
+});

src/models/ActiveSession.ts

@@ -0,0 +1,53 @@
+import { model, Schema } from "mongoose";
+
+const activeSessionSchema = new Schema(
+  {
+    location: {
+      type: String,
+      required: true,
+    },
+    name: {
+      type: String,
+      required: true,
+    },
+    buildName: {
+      type: String,
+      required: true,
+    },
+    uePid: {
+      type: Number,
+      required: true,
+    },
+    cirrusPid: {
+      type: Number,
+      required: true,
+    },
+    uePort: {
+      type: Number,
+      required: true,
+    },
+    cirrusPort: {
+      type: Number,
+      required: true,
+    },
+    ownerIp: {
+      type: String,
+      required: true,
+    },
+    connectedPlayersCount: {
+      type: Number,
+    },
+    endAt: {
+      type: Date,
+    },
+  },
+  {
+    timestamps: true,
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true },
+  }
+);
+
+const ActiveSession = model("Active_Session", activeSessionSchema);
+
+export default ActiveSession;

tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"],
+  "ts-node": {
+    "transpileOnly": true
+  }
+}