code cleanup & fixes

pages/index.vue

@@ -156,7 +156,7 @@
 
         <!-- Delete Button -->
         <form method="dialog">
-          <button class="btn btn-error" @click="deleteServer(editServerDialog)">Delete</button>
+          <button class="btn btn-error" @click="deleteServer(editServerDialog.selectedServer)">Delete</button>
         </form>
       </div>
 
@@ -230,14 +230,8 @@ const getLogs = async () => {
     const response = await axios.post('/api/getLogs', {
       name: serverLogDialog.selectedServer.name
     });
-
-    console.log(response.data.message)
-    //console.log(response)
     const strRet = response.data.logs;
-
-
     const stringArray = strRet.split('\n');
-    //console.log(stringArray);
     serverLogDialog.logs.length = 0;
     stringArray.slice(-20).forEach((element: string) => {
       serverLogDialog.logs.push(element);
@@ -278,12 +272,6 @@ const getProperties = async () => {
 
 
 
-const addServer = async () => {
-  if (!settings.servers.some(server => server.name === addDialog.newServer.name)) {
-    settings.servers.push({ ...addDialog.newServer });
-    await syncServers();
-  }
-}
 
 
 
@@ -312,17 +300,19 @@ const deleteServer = async (server: MinecraftServer) => {
   }
 }
 
-const syncServers = async () => {
+const addServer = async (server: MinecraftServer) => {
   try {
-    const response = await axios.post('/api/setServers', {
+    const response = await axios.post('/api/addServer', {
-      serverList: settings.servers
+      newServer: addDialog.newServer
     });
     console.log(response.data);
-
+    await getServers()
   } catch (error) {
     console.error(`Error `, error);
   }
-};
+}
+
+
 
 
 const startServer = async (server: MinecraftServer) => {

server/api/addServer.ts

@@ -0,0 +1,24 @@
+import {getServerByName, getServerDirectory} from "~/types/MinecraftServer";
+import {environment} from "~/core/globals";
+import {saveJsonFile} from "~/util/jsonLoader";
+
+export default defineEventHandler(async (event) => {
+
+    const body = await readBody(event);
+    const { newServer } = body;
+
+    const server = getServerByName(newServer.name);
+
+    if(server) {
+        return  { message: "Server with name " + newServer.name + " does already exist" };
+    }
+
+    try {
+        environment.settings.servers.push({...newServer})
+        saveJsonFile()
+        return { status: 'success' };
+    } catch (error) {
+        return { status: 'error', error: error };
+    }
+});
+

server/api/deleteServer.ts

@@ -1,23 +1,20 @@
 import {environment} from "~/core/globals";
 import {removeServerByName, saveJsonFile} from "~/util/jsonLoader";
 import * as fs from 'fs/promises';
+import {getServerByName, getServerDirectory} from "~/types/MinecraftServer";
 
 export default defineEventHandler(async (event) => {
     const body = await readBody(event);
     const server_name: string = body.name
-    const server_properties: string = body.properties
+    const server = getServerByName(server_name);
-
-    const server = environment.settings.servers.find(server => server.name == server_name);
 
     if(!server) {
         return  { message: "Server with name " + server_name + " does not exist" };
     }
 
     try {
-        console.log("Recived server list");
         removeServerByName(server.name);
-        const logsPath = environment.paths.servers + "/" + server.name
+        await fs.rm(getServerDirectory(server), { recursive: true, force: true })
-        await fs.rmdir(logsPath)
         saveJsonFile()
 
         return { status: 'success' };

server/api/getLogs.ts

@@ -1,7 +1,7 @@
 import {environment} from "~/core/globals";
 import { defineEventHandler, getCookie, createError } from 'h3';
 import {saveJsonFile} from "~/util/jsonLoader";
-import {MinecraftServer} from "~/types/MinecraftServer";
+import {getLogsPath, getServerByName, MinecraftServer} from "~/types/MinecraftServer";
 import {execa} from "execa";
 import * as fs from 'fs/promises';
 
@@ -9,21 +9,15 @@ import * as fs from 'fs/promises';
 export default defineEventHandler(async (event) => {
     const body = await readBody(event);
     const server_name: string = body.name
-
+    const server = getServerByName(server_name);
-    const server = environment.settings.servers.find(server => server.name == server_name);
-
     if(!server) {
         return  { message: "Server with name " + server_name + " does not exist" };
     }
 
-
-    const workingDir = environment.paths.servers + "/" + server.name;
-    const logsPath = environment.paths.servers + "/" + server.name + "/logs/latest.log";
-
     try {
 
-        const data = await fs.readFile(logsPath, 'utf-8');
+        const rawLogs = await fs.readFile(getLogsPath(server), 'utf-8');
-        const strippedLogs = data.slice(0, -2);
+        const strippedLogs = rawLogs.slice(0, -2);
         return {
             message: `Logs for ${server_name}`,
             logs: strippedLogs

server/api/getProperties.ts

@@ -1,30 +1,24 @@
 import {environment} from "~/core/globals";
 import { defineEventHandler, getCookie, createError } from 'h3';
 import {saveJsonFile} from "~/util/jsonLoader";
-import {MinecraftServer} from "~/types/MinecraftServer";
+import {getPropertiesPath, getServerByName, MinecraftServer} from "~/types/MinecraftServer";
 import {execa} from "execa";
 import * as fs from 'fs/promises';
 
 
 export default defineEventHandler(async (event) => {
-    const body = await readBody(event);
+    const body = await readBody(event)
     const server_name: string = body.name
-
+    const server = getServerByName(server_name)
-    const server = environment.settings.servers.find(server => server.name == server_name);
-
     if(!server) {
         return  { message: "Server with name " + server_name + " does not exist" };
     }
 
-
-    const workingDir = environment.paths.servers + "/" + server.name;
-    const logsPath = environment.paths.servers + "/" + server.name + "/server.properties";
-
     try {
-        const data = await fs.readFile(logsPath, 'utf-8');
+        const serverProperties = await fs.readFile(getPropertiesPath(server), 'utf-8');
         return {
             message: `properties for ${server_name}`,
-            properties: data
+            properties: serverProperties
         };
     } catch (error: any) {
         return { message: "Failed to get logs for " + server_name, error: error.message };

server/api/setProperties.ts

@@ -1,7 +1,7 @@
 import {environment} from "~/core/globals";
 import { defineEventHandler, getCookie, createError } from 'h3';
 import {saveJsonFile} from "~/util/jsonLoader";
-import {MinecraftServer} from "~/types/MinecraftServer";
+import {getPropertiesPath, getServerByName, MinecraftServer} from "~/types/MinecraftServer";
 import {execa} from "execa";
 import * as fs from 'fs/promises';
 
@@ -10,19 +10,12 @@ export default defineEventHandler(async (event) => {
     const body = await readBody(event);
     const server_name: string = body.name
     const server_properties: string = body.properties
-
+    const server = getServerByName(server_name);
-    const server = environment.settings.servers.find(server => server.name == server_name);
-
     if(!server) {
         return  { message: "Server with name " + server_name + " does not exist" };
     }
-
-
-    const workingDir = environment.paths.servers + "/" + server.name;
-    const logsPath = environment.paths.servers + "/" + server.name + "/server.properties";
-
     try {
-        await fs.writeFile(logsPath, server_properties, 'utf8');
+        await fs.writeFile(getPropertiesPath(server), server_properties, 'utf8');
         return {
             message: `properties for ${server_name} set`,
         };

server/api/startServer.ts

@@ -1,27 +1,20 @@
 import {environment} from "~/core/globals";
 import {saveJsonFile} from "~/util/jsonLoader";
-import {MinecraftServer} from "~/types/MinecraftServer";
+import {getJarPath, getServerByName, getServerDirectory, MinecraftServer} from "~/types/MinecraftServer";
 import {execa} from "execa";
 
 
 export default defineEventHandler(async (event) => {
     const body = await readBody(event);
     const server_name: string = body.name
-
+    const server = getServerByName(server_name);
-    const server = environment.settings.servers.find(server => server.name == server_name);
-
     if(!server) {
         return  { message: "Server with name " + server_name + " does not exist" };
     }
-
     if (server.process) {
         return { message: "Minecraft server is already running." };
     }
 
-
-    const workingDir = environment.paths.servers + "/" + server.name;
-    const jarPath = environment.paths.servers + "/" + server.name + "/server.jar";
-
     try {
 
         const xmsArg = `-Xms${server.maxMemory}G`
@@ -29,14 +22,11 @@ export default defineEventHandler(async (event) => {
 
         console.log(`Starting server ${server.name} with ${xmsArg} and ${xmxArg}`);
 
-        server.process = execa('java', [xmsArg, xmxArg, '-jar', jarPath, 'nogui'], {
+        server.process = execa('java', [xmsArg, xmxArg, '-jar', getJarPath(server), 'nogui'], {
-            cwd: workingDir,
+            cwd: getServerDirectory(server),
         });
 
-        server.process.stdout.on('data', (data: string) => {
+        server.process.stdout.on('data', (data: string) => {});
-            const logData = data.toString();
-            //console.log(logData);
-        });
 
         server.process.stderr.on('data', (data: string) => {
             const errorData = data.toString();
@@ -48,7 +38,6 @@ export default defineEventHandler(async (event) => {
             server.process = null;
         })
 
-
         return { message: "Minecraft server started." };
     } catch (error: any) {
         return { message: "Failed to start Minecraft server.", error: error.message };

server/api/stopServer.ts

@@ -1,33 +1,29 @@
 import { environment } from "~/core/globals";
 import { execa } from "execa";
+import {getServerByName} from "~/types/MinecraftServer";
 
 export default defineEventHandler(async (event) => {
     const body = await readBody(event);
     const server_name: string = body.name;
-
+    const server = getServerByName(server_name);
-    const server = environment.settings.servers.find(server => server.name == server_name);
 
     if (!server) {
         return { message: "Server with name " + server_name + " does not exist" };
     }
 
-
     if (!server.process) {
         return { message: "Minecraft server is not running." };
     }
     
 
     try {
-        // Send "stop" command to the server process stdin
         server.process.stdin.write('stop\n');
 
-        // Optionally, listen for the process exit or cleanup
         server.process.on('exit', (code: string) => {
             console.log(`Server exit signal from stopServer with code ${code}`);
             server.process = null;
         });
 
-
         return { message: "Minecraft server is stopping." };
     } catch (error: any) {
         return { message: "Failed to stop Minecraft server.", error: error.message };

types/MinecraftServer.ts

@@ -1,4 +1,3 @@
-import type {ResultPromise} from "execa";
 import {environment} from "~/core/globals";
 
 export interface MinecraftServer {
@@ -21,3 +20,11 @@ export function getJarPath (server: MinecraftServer): string {
 export function getPropertiesPath (server: MinecraftServer): string {
     return environment.paths.servers + "/" + server.name + "/server.properties"
 }
+
+export function getLogsPath (server: MinecraftServer): string {
+    return environment.paths.servers + "/" + server.name + "/logs/latest.log"
+}
+
+export function getServerByName(server_name: string): MinecraftServer | undefined{
+    return environment.settings.servers.find(server => server.name == server_name);
+}

util/jsonLoader.ts

@@ -83,7 +83,7 @@ export function checkAllServerDirectories(){
             console.log('eula exists');
         } catch (error) {
             console.log("setting eula to true")
-            fs.writeFileSync(destinationPathEula, 'eula=true');
+            fs.writeFileSync(destinationPathEula, 'eula=' + environment.settings.eula);
         }
 
     })