Added concurrent sync, added search page. Other small changes

.gitignore

@@ -1 +1,3 @@
-tmp
+tmp
+.DS_Store
+.idea

Dockerfile

@@ -3,6 +3,7 @@ FROM golang:1.22.2-alpine as build_go
 COPY go.* /music-server/
 COPY ./cmd/*.go /music-server/cmd/
 COPY ./cmd/swagger /music-server/cmd/swagger
+COPY ./cmd/search /music-server/cmd/search
 COPY ./pkg /music-server/pkg/
 
 #WORKDIR /music-server/
@@ -27,4 +28,4 @@ ENV DB_NAME ""
 COPY --from=build_go /music-server/MusicServer .
 COPY ./songs/ ./songs/
 
-CMD ./MusicServer
+CMD ./MusicServer

cmd/main.go

@@ -8,10 +8,14 @@ import (
 //go:embed swagger
 var swagger embed.FS
 
+
+//go:embed search
+var search embed.FS
+
 func main() {
 	conf.SetupDb()
 
-	conf.SetupRestServer(swagger)
+	conf.SetupRestServer(swagger, search)
 
 	conf.CloseDb()
 }

cmd/search/index.144x144.png.import

@@ -0,0 +1,34 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://b6bierb3v4yoq"
+path="res://.godot/imported/index.144x144.png-03ea9bc9a40782e35fa8c68f683d2623.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://web/index.144x144.png"
+dest_files=["res://.godot/imported/index.144x144.png-03ea9bc9a40782e35fa8c68f683d2623.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

cmd/search/index.180x180.png.import

@@ -0,0 +1,34 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://b0euyv6xwufjw"
+path="res://.godot/imported/index.180x180.png-9c97e3aaba17027b76e6e765bcdc0add.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://web/index.180x180.png"
+dest_files=["res://.godot/imported/index.180x180.png-9c97e3aaba17027b76e6e765bcdc0add.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

cmd/search/index.512x512.png.import

@@ -0,0 +1,34 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://c30mhkc1yernc"
+path="res://.godot/imported/index.512x512.png-4cda31773312dccaaf53a4ff122aad13.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://web/index.512x512.png"
+dest_files=["res://.godot/imported/index.512x512.png-4cda31773312dccaaf53a4ff122aad13.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

cmd/search/index.apple-touch-icon.png.import

@@ -0,0 +1,34 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://d0tny2k1tdlnq"
+path="res://.godot/imported/index.apple-touch-icon.png-939ec69c79bbf504b92ad8ceed469d51.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://web/index.apple-touch-icon.png"
+dest_files=["res://.godot/imported/index.apple-touch-icon.png-939ec69c79bbf504b92ad8ceed469d51.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

cmd/search/index.audio.worklet.js

@@ -0,0 +1,213 @@
+/**************************************************************************/
+/*  audio.worklet.js                                                      */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+class RingBuffer {
+	constructor(p_buffer, p_state, p_threads) {
+		this.buffer = p_buffer;
+		this.avail = p_state;
+		this.threads = p_threads;
+		this.rpos = 0;
+		this.wpos = 0;
+	}
+
+	data_left() {
+		return this.threads ? Atomics.load(this.avail, 0) : this.avail;
+	}
+
+	space_left() {
+		return this.buffer.length - this.data_left();
+	}
+
+	read(output) {
+		const size = this.buffer.length;
+		let from = 0;
+		let to_write = output.length;
+		if (this.rpos + to_write > size) {
+			const high = size - this.rpos;
+			output.set(this.buffer.subarray(this.rpos, size));
+			from = high;
+			to_write -= high;
+			this.rpos = 0;
+		}
+		if (to_write) {
+			output.set(this.buffer.subarray(this.rpos, this.rpos + to_write), from);
+		}
+		this.rpos += to_write;
+		if (this.threads) {
+			Atomics.add(this.avail, 0, -output.length);
+			Atomics.notify(this.avail, 0);
+		} else {
+			this.avail -= output.length;
+		}
+	}
+
+	write(p_buffer) {
+		const to_write = p_buffer.length;
+		const mw = this.buffer.length - this.wpos;
+		if (mw >= to_write) {
+			this.buffer.set(p_buffer, this.wpos);
+			this.wpos += to_write;
+			if (mw === to_write) {
+				this.wpos = 0;
+			}
+		} else {
+			const high = p_buffer.subarray(0, mw);
+			const low = p_buffer.subarray(mw);
+			this.buffer.set(high, this.wpos);
+			this.buffer.set(low);
+			this.wpos = low.length;
+		}
+		if (this.threads) {
+			Atomics.add(this.avail, 0, to_write);
+			Atomics.notify(this.avail, 0);
+		} else {
+			this.avail += to_write;
+		}
+	}
+}
+
+class GodotProcessor extends AudioWorkletProcessor {
+	constructor() {
+		super();
+		this.threads = false;
+		this.running = true;
+		this.lock = null;
+		this.notifier = null;
+		this.output = null;
+		this.output_buffer = new Float32Array();
+		this.input = null;
+		this.input_buffer = new Float32Array();
+		this.port.onmessage = (event) => {
+			const cmd = event.data['cmd'];
+			const data = event.data['data'];
+			this.parse_message(cmd, data);
+		};
+	}
+
+	process_notify() {
+		if (this.notifier) {
+			Atomics.add(this.notifier, 0, 1);
+			Atomics.notify(this.notifier, 0);
+		}
+	}
+
+	parse_message(p_cmd, p_data) {
+		if (p_cmd === 'start' && p_data) {
+			const state = p_data[0];
+			let idx = 0;
+			this.threads = true;
+			this.lock = state.subarray(idx, ++idx);
+			this.notifier = state.subarray(idx, ++idx);
+			const avail_in = state.subarray(idx, ++idx);
+			const avail_out = state.subarray(idx, ++idx);
+			this.input = new RingBuffer(p_data[1], avail_in, true);
+			this.output = new RingBuffer(p_data[2], avail_out, true);
+		} else if (p_cmd === 'stop') {
+			this.running = false;
+			this.output = null;
+			this.input = null;
+			this.lock = null;
+			this.notifier = null;
+		} else if (p_cmd === 'start_nothreads') {
+			this.output = new RingBuffer(p_data[0], p_data[0].length, false);
+		} else if (p_cmd === 'chunk') {
+			this.output.write(p_data);
+		}
+	}
+
+	static array_has_data(arr) {
+		return arr.length && arr[0].length && arr[0][0].length;
+	}
+
+	process(inputs, outputs, parameters) {
+		if (!this.running) {
+			return false; // Stop processing.
+		}
+		if (this.output === null) {
+			return true; // Not ready yet, keep processing.
+		}
+		const process_input = GodotProcessor.array_has_data(inputs);
+		if (process_input) {
+			const input = inputs[0];
+			const chunk = input[0].length * input.length;
+			if (this.input_buffer.length !== chunk) {
+				this.input_buffer = new Float32Array(chunk);
+			}
+			if (!this.threads) {
+				GodotProcessor.write_input(this.input_buffer, input);
+				this.port.postMessage({ 'cmd': 'input', 'data': this.input_buffer });
+			} else if (this.input.space_left() >= chunk) {
+				GodotProcessor.write_input(this.input_buffer, input);
+				this.input.write(this.input_buffer);
+			} else {
+				// this.port.postMessage('Input buffer is full! Skipping input frame.'); // Uncomment this line to debug input buffer.
+			}
+		}
+		const process_output = GodotProcessor.array_has_data(outputs);
+		if (process_output) {
+			const output = outputs[0];
+			const chunk = output[0].length * output.length;
+			if (this.output_buffer.length !== chunk) {
+				this.output_buffer = new Float32Array(chunk);
+			}
+			if (this.output.data_left() >= chunk) {
+				this.output.read(this.output_buffer);
+				GodotProcessor.write_output(output, this.output_buffer);
+				if (!this.threads) {
+					this.port.postMessage({ 'cmd': 'read', 'data': chunk });
+				}
+			} else {
+				// this.port.postMessage('Output buffer has not enough frames! Skipping output frame.'); // Uncomment this line to debug output buffer.
+			}
+		}
+		this.process_notify();
+		return true;
+	}
+
+	static write_output(dest, source) {
+		const channels = dest.length;
+		for (let ch = 0; ch < channels; ch++) {
+			for (let sample = 0; sample < dest[ch].length; sample++) {
+				dest[ch][sample] = source[sample * channels + ch];
+			}
+		}
+	}
+
+	static write_input(dest, source) {
+		const channels = source.length;
+		for (let ch = 0; ch < channels; ch++) {
+			for (let sample = 0; sample < source[ch].length; sample++) {
+				dest[sample * channels + ch] = source[ch][sample];
+			}
+		}
+	}
+}
+
+registerProcessor('godot-processor', GodotProcessor);

cmd/search/index.html

@@ -0,0 +1,200 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8">
+		<meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0">
+		<title>MusicSearch</title>
+		<style>
+html, body, #canvas {
+	margin: 0;
+	padding: 0;
+	border: 0;
+}
+
+body {
+	color: white;
+	background-color: black;
+	overflow: hidden;
+	touch-action: none;
+}
+
+#canvas {
+	display: block;
+}
+
+#canvas:focus {
+	outline: none;
+}
+
+#status, #status-splash, #status-progress {
+	position: absolute;
+	left: 0;
+	right: 0;
+}
+
+#status, #status-splash {
+	top: 0;
+	bottom: 0;
+}
+
+#status {
+	background-color: #242424;
+	display: flex;
+	flex-direction: column;
+	justify-content: center;
+	align-items: center;
+	visibility: hidden;
+}
+
+#status-splash {
+	max-height: 100%;
+	max-width: 100%;
+	margin: auto;
+}
+
+#status-progress, #status-notice {
+	display: none;
+}
+
+#status-progress {
+	bottom: 10%;
+	width: 50%;
+	margin: 0 auto;
+}
+
+#status-notice {
+	background-color: #5b3943;
+	border-radius: 0.5rem;
+	border: 1px solid #9b3943;
+	color: #e0e0e0;
+	font-family: 'Noto Sans', 'Droid Sans', Arial, sans-serif;
+	line-height: 1.3;
+	margin: 0 2rem;
+	overflow: hidden;
+	padding: 1rem;
+	text-align: center;
+	z-index: 1;
+}
+		</style>
+		<link id="-gd-engine-icon" rel="icon" type="image/png" href="index.icon.png" />
+<link rel="apple-touch-icon" href="index.apple-touch-icon.png"/>
+<link rel="manifest" href="index.manifest.json">
+
+	</head>
+	<body>
+		<canvas id="canvas">
+			Your browser does not support the canvas tag.
+		</canvas>
+
+		<noscript>
+			Your browser does not support JavaScript.
+		</noscript>
+
+		<div id="status">
+			<img id="status-splash" src="index.png" alt="">
+			<progress id="status-progress"></progress>
+			<div id="status-notice"></div>
+		</div>
+
+		<script src="index.js"></script>
+		<script>
+const GODOT_CONFIG = {"args":[],"canvasResizePolicy":2,"ensureCrossOriginIsolationHeaders":false,"executable":"index","experimentalVK":false,"fileSizes":{"index.pck":86816,"index.wasm":35376909},"focusCanvas":true,"gdextensionLibs":[],"serviceWorker":"index.service.worker.js"};
+const GODOT_THREADS_ENABLED = false;
+const engine = new Engine(GODOT_CONFIG);
+
+(function () {
+	const statusOverlay = document.getElementById('status');
+	const statusProgress = document.getElementById('status-progress');
+	const statusNotice = document.getElementById('status-notice');
+
+	let initializing = true;
+	let statusMode = '';
+
+	function setStatusMode(mode) {
+		if (statusMode === mode || !initializing) {
+			return;
+		}
+		if (mode === 'hidden') {
+			statusOverlay.remove();
+			initializing = false;
+			return;
+		}
+		statusOverlay.style.visibility = 'visible';
+		statusProgress.style.display = mode === 'progress' ? 'block' : 'none';
+		statusNotice.style.display = mode === 'notice' ? 'block' : 'none';
+		statusMode = mode;
+	}
+
+	function setStatusNotice(text) {
+		while (statusNotice.lastChild) {
+			statusNotice.removeChild(statusNotice.lastChild);
+		}
+		const lines = text.split('\n');
+		lines.forEach((line) => {
+			statusNotice.appendChild(document.createTextNode(line));
+			statusNotice.appendChild(document.createElement('br'));
+		});
+	}
+
+	function displayFailureNotice(err) {
+		console.error(err);
+		if (err instanceof Error) {
+			setStatusNotice(err.message);
+		} else if (typeof err === 'string') {
+			setStatusNotice(err);
+		} else {
+			setStatusNotice('An unknown error occured');
+		}
+		setStatusMode('notice');
+		initializing = false;
+	}
+
+	const missing = Engine.getMissingFeatures({
+		threads: GODOT_THREADS_ENABLED,
+	});
+
+	if (missing.length !== 0) {
+		if (GODOT_CONFIG['serviceWorker'] && GODOT_CONFIG['ensureCrossOriginIsolationHeaders'] && 'serviceWorker' in navigator) {
+			// There's a chance that installing the service worker would fix the issue
+			Promise.race([
+				navigator.serviceWorker.getRegistration().then((registration) => {
+					if (registration != null) {
+						return Promise.reject(new Error('Service worker already exists.'));
+					}
+					return registration;
+				}).then(() => engine.installServiceWorker()),
+				// For some reason, `getRegistration()` can stall
+				new Promise((resolve) => {
+					setTimeout(() => resolve(), 2000);
+				}),
+			]).catch((err) => {
+				console.error('Error while registering service worker:', err);
+			}).then(() => {
+				window.location.reload();
+			});
+		} else {
+			// Display the message as usual
+			const missingMsg = 'Error\nThe following features required to run Godot projects on the Web are missing:\n';
+			displayFailureNotice(missingMsg + missing.join('\n'));
+		}
+	} else {
+		setStatusMode('progress');
+		engine.startGame({
+			'onProgress': function (current, total) {
+				if (current > 0 && total > 0) {
+					statusProgress.value = current;
+					statusProgress.max = total;
+				} else {
+					statusProgress.removeAttribute('value');
+					statusProgress.removeAttribute('max');
+				}
+			},
+		}).then(() => {
+			setStatusMode('hidden');
+		}, displayFailureNotice);
+	}
+}());
+		</script>
+	</body>
+</html>
+

cmd/search/index.icon.png.import

@@ -0,0 +1,34 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://c8gblkbcsrrwo"
+path="res://.godot/imported/index.icon.png-c615af856eabc03ca93d51f6a8f07b60.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://web/index.icon.png"
+dest_files=["res://.godot/imported/index.icon.png-c615af856eabc03ca93d51f6a8f07b60.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

cmd/search/index.manifest.json

@@ -0,0 +1 @@
+{"background_color":"#000000","display":"standalone","icons":[{"sizes":"144x144","src":"index.144x144.png","type":"image/png"},{"sizes":"180x180","src":"index.180x180.png","type":"image/png"},{"sizes":"512x512","src":"index.512x512.png","type":"image/png"}],"name":"MusicSearch","orientation":"any","start_url":"./index.html"}

cmd/search/index.offline.html

@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8">
+		<meta http-equiv="X-UA-Compatible" content="IE=edge">
+		<meta name="viewport" content="width=device-width, initial-scale=1">
+		<title>You are offline</title>
+		<style>
+html {
+	background-color: #000000;
+	color: #ffffff;
+}
+
+body {
+	font-family: system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+	margin: 2rem;
+}
+
+p {
+	margin-block: 1rem;
+}
+
+button {
+	display: block;
+	padding: 1rem 2rem;
+	margin: 3rem auto 0;
+}
+		</style>
+	</head>
+	<body>
+		<h1>You are offline</h1>
+		<p>This application requires an Internet connection to run for the first time.</p>
+		<p>Press the button below to try reloading:</p>
+		<button type="button">Reload</button>
+		<script>
+document.querySelector('button').addEventListener('click', () => {
+	window.location.reload();
+});
+		</script>
+	</body>
+</html>

cmd/search/index.png.import

@@ -0,0 +1,34 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://bxh15ilo8hoq"
+path="res://.godot/imported/index.png-80964ad67552d78b1e33f58ad16188ff.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://web/index.png"
+dest_files=["res://.godot/imported/index.png-80964ad67552d78b1e33f58ad16188ff.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

cmd/search/index.service.worker.js

@@ -0,0 +1,166 @@
+// This service worker is required to expose an exported Godot project as a
+// Progressive Web App. It provides an offline fallback page telling the user
+// that they need an Internet connection to run the project if desired.
+// Incrementing CACHE_VERSION will kick off the install event and force
+// previously cached resources to be updated from the network.
+/** @type {string} */
+const CACHE_VERSION = '1726998131|1051448710';
+/** @type {string} */
+const CACHE_PREFIX = 'MusicSearch-sw-cache-';
+const CACHE_NAME = CACHE_PREFIX + CACHE_VERSION;
+/** @type {string} */
+const OFFLINE_URL = 'index.offline.html';
+/** @type {boolean} */
+const ENSURE_CROSSORIGIN_ISOLATION_HEADERS = false;
+// Files that will be cached on load.
+/** @type {string[]} */
+const CACHED_FILES = ["index.html","index.js","index.offline.html","index.icon.png","index.apple-touch-icon.png","index.worker.js","index.audio.worklet.js"];
+// Files that we might not want the user to preload, and will only be cached on first load.
+/** @type {string[]} */
+const CACHABLE_FILES = ["index.wasm","index.pck"];
+const FULL_CACHE = CACHED_FILES.concat(CACHABLE_FILES);
+
+self.addEventListener('install', (event) => {
+	event.waitUntil(caches.open(CACHE_NAME).then((cache) => cache.addAll(CACHED_FILES)));
+});
+
+self.addEventListener('activate', (event) => {
+	event.waitUntil(caches.keys().then(
+		function (keys) {
+			// Remove old caches.
+			return Promise.all(keys.filter((key) => key.startsWith(CACHE_PREFIX) && key !== CACHE_NAME).map((key) => caches.delete(key)));
+		}
+	).then(function () {
+		// Enable navigation preload if available.
+		return ('navigationPreload' in self.registration) ? self.registration.navigationPreload.enable() : Promise.resolve();
+	}));
+});
+
+/**
+ * Ensures that the response has the correct COEP/COOP headers
+ * @param {Response} response
+ * @returns {Response}
+ */
+function ensureCrossOriginIsolationHeaders(response) {
+	if (response.headers.get('Cross-Origin-Embedder-Policy') === 'require-corp'
+		&& response.headers.get('Cross-Origin-Opener-Policy') === 'same-origin') {
+		return response;
+	}
+
+	const crossOriginIsolatedHeaders = new Headers(response.headers);
+	crossOriginIsolatedHeaders.set('Cross-Origin-Embedder-Policy', 'require-corp');
+	crossOriginIsolatedHeaders.set('Cross-Origin-Opener-Policy', 'same-origin');
+	const newResponse = new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: crossOriginIsolatedHeaders,
+	});
+
+	return newResponse;
+}
+
+/**
+ * Calls fetch and cache the result if it is cacheable
+ * @param {FetchEvent} event
+ * @param {Cache} cache
+ * @param {boolean} isCacheable
+ * @returns {Response}
+ */
+async function fetchAndCache(event, cache, isCacheable) {
+	// Use the preloaded response, if it's there
+	/** @type { Response } */
+	let response = await event.preloadResponse;
+	if (response == null) {
+		// Or, go over network.
+		response = await self.fetch(event.request);
+	}
+
+	if (ENSURE_CROSSORIGIN_ISOLATION_HEADERS) {
+		response = ensureCrossOriginIsolationHeaders(response);
+	}
+
+	if (isCacheable) {
+		// And update the cache
+		cache.put(event.request, response.clone());
+	}
+
+	return response;
+}
+
+self.addEventListener(
+	'fetch',
+	/**
+	 * Triggered on fetch
+	 * @param {FetchEvent} event
+	 */
+	(event) => {
+		const isNavigate = event.request.mode === 'navigate';
+		const url = event.request.url || '';
+		const referrer = event.request.referrer || '';
+		const base = referrer.slice(0, referrer.lastIndexOf('/') + 1);
+		const local = url.startsWith(base) ? url.replace(base, '') : '';
+		const isCachable = FULL_CACHE.some((v) => v === local) || (base === referrer && base.endsWith(CACHED_FILES[0]));
+		if (isNavigate || isCachable) {
+			event.respondWith((async () => {
+				// Try to use cache first
+				const cache = await caches.open(CACHE_NAME);
+				if (isNavigate) {
+					// Check if we have full cache during HTML page request.
+					/** @type {Response[]} */
+					const fullCache = await Promise.all(FULL_CACHE.map((name) => cache.match(name)));
+					const missing = fullCache.some((v) => v === undefined);
+					if (missing) {
+						try {
+							// Try network if some cached file is missing (so we can display offline page in case).
+							const response = await fetchAndCache(event, cache, isCachable);
+							return response;
+						} catch (e) {
+							// And return the hopefully always cached offline page in case of network failure.
+							console.error('Network error: ', e); // eslint-disable-line no-console
+							return caches.match(OFFLINE_URL);
+						}
+					}
+				}
+				let cached = await cache.match(event.request);
+				if (cached != null) {
+					if (ENSURE_CROSSORIGIN_ISOLATION_HEADERS) {
+						cached = ensureCrossOriginIsolationHeaders(cached);
+					}
+					return cached;
+				}
+				// Try network if don't have it in cache.
+				const response = await fetchAndCache(event, cache, isCachable);
+				return response;
+			})());
+		} else if (ENSURE_CROSSORIGIN_ISOLATION_HEADERS) {
+			event.respondWith((async () => {
+				let response = await fetch(event.request);
+				response = ensureCrossOriginIsolationHeaders(response);
+				return response;
+			})());
+		}
+	}
+);
+
+self.addEventListener('message', (event) => {
+	// No cross origin
+	if (event.origin !== self.origin) {
+		return;
+	}
+	const id = event.source.id || '';
+	const msg = event.data || '';
+	// Ensure it's one of our clients.
+	self.clients.get(id).then(function (client) {
+		if (!client) {
+			return; // Not a valid client.
+		}
+		if (msg === 'claim') {
+			self.skipWaiting().then(() => self.clients.claim());
+		} else if (msg === 'clear') {
+			caches.delete(CACHE_NAME);
+		} else if (msg === 'update') {
+			self.skipWaiting().then(() => self.clients.claim()).then(() => self.clients.matchAll()).then((all) => all.forEach((c) => c.navigate(c.url)));
+		}
+	});
+});
+

go.mod

@@ -23,6 +23,7 @@ require (
 	github.com/jackc/pgio v1.0.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9 // indirect
+	github.com/jackc/puddle/v2 v2.2.1 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
@@ -35,6 +36,7 @@ require (
 	golang.org/x/arch v0.8.0 // indirect
 	golang.org/x/crypto v0.23.0 // indirect
 	golang.org/x/net v0.25.0 // indirect
+	golang.org/x/sync v0.1.0 // indirect
 	golang.org/x/sys v0.20.0 // indirect
 	golang.org/x/text v0.15.0 // indirect
 	google.golang.org/protobuf v1.34.1 // indirect

go.sum

@@ -93,7 +93,6 @@ github.com/jackc/pgx/v5 v5.5.5/go.mod h1:ez9gk+OAat140fv9ErkZDYFWmXLfV+++K0uAOiw
 github.com/jackc/puddle v0.0.0-20190413234325-e4ced69a3a2b/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
 github.com/jackc/puddle v0.0.0-20190608224051-11cab39313c9/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
 github.com/jackc/puddle v1.1.3/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
-github.com/jackc/puddle v1.3.0 h1:eHK/5clGOatcjX3oWGBO/MpxpbHzSwud5EWTSCI+MX0=
 github.com/jackc/puddle v1.3.0/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
 github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
 github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=

pkg/api/sync.go

@@ -19,6 +19,12 @@ func (s *Sync) SyncGames(ctx *gin.Context) {
 	ctx.JSON(http.StatusOK, "Games are synced")
 }
 
+func (s *Sync) SyncGamesQuick(ctx *gin.Context) {
+	server.SyncGamesQuick()
+	server.Reset()
+	ctx.JSON(http.StatusOK, "Games are synced")
+}
+
 func (s *Sync) ResetGames(ctx *gin.Context) {
 	server.ResetDB()
 	ctx.JSON(http.StatusOK, "Games and songs are deleted from the database")

pkg/conf/conf.go

@@ -3,14 +3,15 @@ package conf
 import (
 	"embed"
 	"fmt"
-	"github.com/gin-contrib/static"
-	"github.com/gin-gonic/gin"
 	"log"
 	"music-server/pkg/api"
 	"music-server/pkg/db"
 	"music-server/pkg/helpers"
 	"os"
 	"strconv"
+
+	"github.com/gin-contrib/static"
+	"github.com/gin-gonic/gin"
 )
 
 func SetupDb() {
@@ -50,7 +51,7 @@ func CloseDb() {
 	defer db.CloseDb()
 }
 
-func SetupRestServer(swagger embed.FS) {
+func SetupRestServer(swagger embed.FS, search embed.FS) {
 
 	router := gin.Default()
 	router.Use(helpers.SetCorsAndNoCacheHeaders())
@@ -59,6 +60,7 @@ func SetupRestServer(swagger embed.FS) {
 	syncGroup := router.Group("/sync")
 	{
 		syncGroup.GET("", sync.SyncGames)
+		syncGroup.GET("/quick", sync.SyncGamesQuick)
 		syncGroup.GET("/reset", sync.ResetGames)
 	}
 
@@ -87,8 +89,10 @@ func SetupRestServer(swagger embed.FS) {
 	router.GET("/version", index.GetVersion)
 	router.GET("/test", index.GetDBTest)
 	router.StaticFS("/swagger", helpers.EmbedFolder(swagger, "swagger", false))
+	router.StaticFS("/search", helpers.EmbedFolder(search, "search", true))
 	router.Use(static.Serve("/", static.LocalFile("/frontend", true)))
 	router.Use(static.Serve("/new", static.LocalFile("/newFrontend", true)))
+	//router.Use(static.Serve("/search", static.LocalFile("/search", true)))
 
 	port := os.Getenv("PORT")
 	if port == "" {

pkg/db/dbHelper.go

@@ -3,11 +3,13 @@ package db
 import (
 	"context"
 	"fmt"
-	"github.com/jackc/pgx/v5"
 	"os"
+
+	"github.com/jackc/pgx/v5/pgxpool"
 )
 
-var pool *pgx.Conn
+var dbpool *pgxpool.Pool
+var ctx = context.Background()
 
 func InitDB(host string, port int, user string, password string, dbname string) {
 
@@ -18,14 +20,14 @@ func InitDB(host string, port int, user string, password string, dbname string)
 	fmt.Println(psqlInfo)
 
 	var err error
-	pool, err = pgx.Connect(context.Background(), psqlInfo)
+	dbpool, err = pgxpool.New(ctx, psqlInfo)
 	if err != nil {
 		_, _ = fmt.Fprintf(os.Stderr, "Unable to connect to database: %v\n", err)
 		os.Exit(1)
 	}
 
 	var success string
-	err = pool.QueryRow(context.Background(), "select 'Successfully connected!'").Scan(&success)
+	err = dbpool.QueryRow(ctx, "select 'Successfully connected!'").Scan(&success)
 	if err != nil {
 		_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
 		os.Exit(1)
@@ -35,14 +37,11 @@ func InitDB(host string, port int, user string, password string, dbname string)
 }
 
 func CloseDb() {
-	err := pool.Close(context.Background())
-	if err != nil {
-		return
-	}
+	dbpool.Close()
 }
 
 func Testf() {
-	rows, dbErr := pool.Query(context.Background(), "select game_name from game")
+	rows, dbErr := dbpool.Query(ctx, "select game_name from game")
 	if dbErr != nil {
 		_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", dbErr)
 		os.Exit(1)
@@ -58,7 +57,7 @@ func Testf() {
 }
 
 func resetGameIdSeq() {
-	_, err := pool.Query(context.Background(), "SELECT setval('game_id_seq', (SELECT MAX(id) FROM game)+1);")
+	_, err := dbpool.Query(ctx, "SELECT setval('game_id_seq', (SELECT MAX(id) FROM game)+1);")
 	if err != nil {
 		_, _ = fmt.Fprintf(os.Stderr, "Exec failed: %v\n", err)
 	}

pkg/db/game.go

@@ -1,7 +1,6 @@
 package db
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"music-server/pkg/models"
@@ -13,10 +12,12 @@ import (
 
 func GetGameName(gameId int) string {
 	var gameName = ""
-	err := pool.QueryRow(context.Background(),
+	err := dbpool.QueryRow(ctx,
 		"SELECT game_name FROM game WHERE id = $1", gameId).Scan(&gameName)
 	if err != nil {
-		_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		if compareError.Error() != err.Error() {
+			_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		}
 		return ""
 	}
 	return gameName
@@ -27,11 +28,13 @@ func GetGameById(gameId int) (models.GameData, error) {
 	var numberOfSongs pgtype.Int4
 	var gameName, path string
 	var added, deleted, lastChanged, lastPlayed pgtype.Timestamp
-	err := pool.QueryRow(context.Background(),
+	err := dbpool.QueryRow(ctx,
 		"SELECT id, game_name, added, deleted, last_changed, path, times_played, last_played, number_of_songs "+
 			"FROM game WHERE id = $1 AND deleted IS NULL ", gameId).Scan(&id, &gameName, &added, &deleted, &lastChanged, &path, &timesPlayed, &lastPlayed, &numberOfSongs)
 	if err != nil {
-		_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		if compareError.Error() != err.Error() {
+			_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		}
 		return models.GameData{}, errors.New("Game not found")
 	}
 	return models.GameData{
@@ -48,7 +51,7 @@ func GetGameById(gameId int) (models.GameData, error) {
 }
 
 func SetGameDeletionDate() {
-	_, err := pool.Exec(context.Background(),
+	_, err := dbpool.Exec(ctx,
 		"UPDATE game SET deleted=$1 WHERE deleted IS NULL", time.Now())
 	if err != nil {
 		_, _ = fmt.Fprintf(os.Stderr, "Exec failed: %v\n", err)
@@ -56,14 +59,14 @@ func SetGameDeletionDate() {
 }
 
 func ClearGames() {
-	_, err := pool.Exec(context.Background(), "DELETE FROM game")
+	_, err := dbpool.Exec(ctx, "DELETE FROM game")
 	if err != nil {
 		_, _ = fmt.Fprintf(os.Stderr, "Exec failed: %v\n", err)
 	}
 }
 
 func UpdateGameName(id int, name string, path string) {
-	_, err := pool.Exec(context.Background(),
+	_, err := dbpool.Exec(ctx,
 		"UPDATE game SET game_name=$1, path=$2, last_changed=$3 WHERE id=$4",
 		name, path, time.Now(), id)
 	if err != nil {
@@ -72,7 +75,7 @@ func UpdateGameName(id int, name string, path string) {
 }
 
 func RemoveDeletionDate(id int) {
-	_, err := pool.Exec(context.Background(),
+	_, err := dbpool.Exec(ctx,
 		"UPDATE game SET deleted=null WHERE id=$1", id)
 	if err != nil {
 		_, _ = fmt.Fprintf(os.Stderr, "Exec failed: %v\n", err)
@@ -81,10 +84,12 @@ func RemoveDeletionDate(id int) {
 
 func GetIdByGameName(name string) int {
 	var gameId = -1
-	err := pool.QueryRow(context.Background(),
+	err := dbpool.QueryRow(ctx,
 		"SELECT id FROM game WHERE game_name = $1", name).Scan(&gameId)
 	if err != nil {
-		_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		if compareError.Error() != err.Error() {
+			_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		}
 		return -1
 	}
 	return gameId
@@ -92,17 +97,21 @@ func GetIdByGameName(name string) int {
 
 func InsertGame(name string, path string) int {
 	gameId := -1
-	err := pool.QueryRow(context.Background(),
+	err := dbpool.QueryRow(ctx,
 		"INSERT INTO game(game_name, path, added) VALUES ($1, $2, $3) RETURNING id",
 		name, path, time.Now()).Scan(&gameId)
 	if err != nil {
-		_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		if compareError.Error() != err.Error() {
+			_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		}
 		resetGameIdSeq()
-		err2 := pool.QueryRow(context.Background(),
+		err2 := dbpool.QueryRow(ctx,
 			"INSERT INTO game(game_name, path, added) VALUES ($1, $2, $3) RETURNING id",
 			name, path, time.Now()).Scan(&gameId)
 		if err2 != nil {
-			_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+			if compareError.Error() != err2.Error() {
+				_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+			}
 			return -1
 		}
 	}
@@ -110,7 +119,7 @@ func InsertGame(name string, path string) int {
 }
 
 func InsertGameWithExistingId(id int, name string, path string) {
-	_, err := pool.Exec(context.Background(),
+	_, err := dbpool.Exec(ctx,
 		"INSERT INTO game(id, game_name, path, added) VALUES ($1, $2, $3, $4)",
 		id, name, path, time.Now())
 	if err != nil {
@@ -119,12 +128,14 @@ func InsertGameWithExistingId(id int, name string, path string) {
 }
 
 func FindAllGames() []models.GameData {
-	rows, err := pool.Query(context.Background(),
+	rows, err := dbpool.Query(ctx,
 		"SELECT id, game_name, added, deleted, last_changed, path, times_played, last_played, number_of_songs "+
 			"FROM game WHERE deleted IS NULL "+
 			"ORDER BY game_name")
 	if err != nil {
-		_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		if compareError.Error() != err.Error() {
+			_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		}
 	}
 	var gameList []models.GameData
 	for rows.Next() {
@@ -134,7 +145,9 @@ func FindAllGames() []models.GameData {
 		var added, deleted, lastChanged, lastPlayed pgtype.Timestamp
 		err := rows.Scan(&id, &gameName, &added, &deleted, &lastChanged, &path, &timesPlayed, &lastPlayed, &numberOfSongs)
 		if err != nil {
-			_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+			if compareError.Error() != err.Error() {
+				_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+			}
 		}
 		gameList = append(gameList, models.GameData{
 			Id:            id,
@@ -152,7 +165,7 @@ func FindAllGames() []models.GameData {
 }
 
 func AddGamePlayed(id int) {
-	_, err := pool.Exec(context.Background(),
+	_, err := dbpool.Exec(ctx,
 		"UPDATE game SET times_played=times_played+1, last_played=now() WHERE id=$1", id)
 	if err != nil {
 		_, _ = fmt.Fprintf(os.Stderr, "Exec failed: %v\n", err)

pkg/db/song.go

@@ -1,21 +1,23 @@
 package db
 
 import (
-	"context"
+	"errors"
 	"fmt"
 	"music-server/pkg/models"
 	"os"
 	"strings"
 )
 
+var compareError = errors.New("no rows in result set")
+
 func ClearSongs(gameId int) {
 	if gameId == -1 {
-		_, err := pool.Exec(context.Background(), "DELETE FROM song")
+		_, err := dbpool.Exec(ctx, "DELETE FROM song")
 		if err != nil {
 			_, _ = fmt.Fprintf(os.Stderr, "Exec failed: %v\n", err)
 		}
 	} else {
-		_, err := pool.Exec(context.Background(), "DELETE FROM song where game_id=$1", gameId)
+		_, err := dbpool.Exec(ctx, "DELETE FROM song where game_id=$1", gameId)
 		if err != nil {
 			_, _ = fmt.Fprintf(os.Stderr, "Exec failed: %v\n", err)
 		}
@@ -23,7 +25,7 @@ func ClearSongs(gameId int) {
 }
 
 func AddSong(song models.SongData) {
-	_, err := pool.Exec(context.Background(),
+	_, err := dbpool.Exec(ctx,
 		"INSERT INTO song(game_id, song_name, path, file_name) VALUES ($1, $2, $3, $4)",
 		song.GameId, song.SongName, song.Path, song.FileName)
 	if err != nil {
@@ -33,17 +35,18 @@ func AddSong(song models.SongData) {
 
 func CheckSong(songPath string) bool {
 	var path string
-	err := pool.QueryRow(context.Background(),
+	err := dbpool.QueryRow(ctx,
 		"SELECT path FROM song WHERE path = $1", songPath).Scan(&path)
 	if err != nil {
-		_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		if compareError.Error() != err.Error() {
+			_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		}
 	}
-	println("CheckSong path", path)
 	return path != ""
 }
 
 func UpdateSong(songName string, fileName string, path string) {
-	_, err := pool.Exec(context.Background(),
+	_, err := dbpool.Exec(ctx,
 		"UPDATE song SET song_name=$1, file_name=$2 WHERE path = $3",
 		songName, fileName, path)
 	if err != nil {
@@ -52,10 +55,12 @@ func UpdateSong(songName string, fileName string, path string) {
 }
 
 func FindSongsFromGame(id int) []models.SongData {
-	rows, err := pool.Query(context.Background(),
+	rows, err := dbpool.Query(ctx,
 		"SELECT song_name, path, file_name, times_played FROM song WHERE game_id = $1", id)
 	if err != nil {
-		_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		if compareError.Error() != err.Error() {
+			_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		}
 		return nil
 	}
 
@@ -68,7 +73,9 @@ func FindSongsFromGame(id int) []models.SongData {
 
 		err := rows.Scan(&songName, &path, &fileName, &timesPlayed)
 		if err != nil {
-			_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+			if compareError.Error() != err.Error() {
+				_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+			}
 		}
 
 		songDataList = append(songDataList, models.SongData{
@@ -83,7 +90,7 @@ func FindSongsFromGame(id int) []models.SongData {
 }
 
 func AddSongPlayed(id int, name string) {
-	_, err := pool.Exec(context.Background(),
+	_, err := dbpool.Exec(ctx,
 		"UPDATE song SET times_played=times_played+1 WHERE game_id=$1 AND song_name=$2", id, name)
 	if err != nil {
 		_, _ = fmt.Fprintf(os.Stderr, "Exec failed: %v\n", err)
@@ -91,10 +98,12 @@ func AddSongPlayed(id int, name string) {
 }
 
 func FetchAllSongs() []models.SongData {
-	rows, err := pool.Query(context.Background(),
+	rows, err := dbpool.Query(ctx,
 		"SELECT song_name, path FROM song")
 	if err != nil {
-		_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		if compareError.Error() != err.Error() {
+			_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		}
 		return nil
 	}
 
@@ -105,7 +114,9 @@ func FetchAllSongs() []models.SongData {
 
 		err := rows.Scan(&songName, &path)
 		if err != nil {
-			_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+			if compareError.Error() != err.Error() {
+				_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+			}
 		}
 
 		songDataList = append(songDataList, models.SongData{
@@ -117,7 +128,7 @@ func FetchAllSongs() []models.SongData {
 }
 
 func RemoveBrokenSong(song models.SongData) {
-	_, err := pool.Exec(context.Background(), "DELETE FROM song where path=$1", song.Path)
+	_, err := dbpool.Exec(ctx, "DELETE FROM song where path=$1", song.Path)
 	if err != nil {
 		_, _ = fmt.Fprintf(os.Stderr, "Exec failed: %v\n", err)
 	}
@@ -130,7 +141,7 @@ func RemoveBrokenSongs(songs []models.SongData) {
 	}
 	joined = strings.TrimSuffix(joined, ",")
 
-	_, err := pool.Exec(context.Background(), "DELETE FROM song where path in ($1)", joined)
+	_, err := dbpool.Exec(ctx, "DELETE FROM song where path in ($1)", joined)
 	if err != nil {
 		_, _ = fmt.Fprintf(os.Stderr, "Exec failed: %v\n", err)
 	}

pkg/db/songList.go

@@ -1,7 +1,6 @@
 package db
 
 import (
-	"context"
 	"fmt"
 	"music-server/pkg/models"
 	"os"
@@ -9,7 +8,7 @@ import (
 )
 
 func InsertSongInList(song models.SongListData) {
-	err := pool.QueryRow(context.Background(),
+	_, err := dbpool.Exec(ctx,
 		`INSERT INTO song_list (match_date, match_id, song_no, game_name, song_name) VALUES ($1, $2, $3, $4, $5)`,
 		song.MatchDate, song.MatchId, song.SongNo, song.GameName, song.SongName)
 	if err != nil {
@@ -18,12 +17,14 @@ func InsertSongInList(song models.SongListData) {
 }
 
 func GetSongList(matchId int) []models.SongListData {
-	rows, err := pool.Query(context.Background(),
+	rows, err := dbpool.Query(ctx,
 		"SELECT match_date, match_id, song_no, game_name, song_name "+
 			"FROM song_list WHERE match_date = $1"+
 			"ORDER BY song_no DESC", matchId)
 	if err != nil {
-		_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		if compareError.Error() != err.Error() {
+			_, _ = fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
+		}
 	}
 	var songList []models.SongListData
 	for rows.Next() {

pkg/helpers/helpers.go

@@ -3,14 +3,15 @@ package helpers
 import (
 	"embed"
 	"fmt"
-	"github.com/gin-contrib/static"
-	"github.com/gin-gonic/gin"
 	"io"
 	"io/fs"
 	"net/http"
 	"os"
 	"strconv"
 	"time"
+
+	"github.com/gin-contrib/static"
+	"github.com/gin-gonic/gin"
 )
 
 func SetCorsAndNoCacheHeaders() gin.HandlerFunc {

pkg/server/music.go

@@ -7,6 +7,7 @@ import (
 	"music-server/pkg/models"
 	"os"
 	"strconv"
+	"strings"
 )
 
 var currentSong = -1
@@ -232,9 +233,9 @@ func getSongFromList(games []models.GameData) models.SongData {
 	var song models.SongData
 	for !songFound {
 		game := getRandomGame(games)
-		log.Println("game = ", game)
+		//log.Println("game = ", game)
 		songs := db.FindSongsFromGame(game.Id)
-		log.Println("songs = ", songs)
+		//log.Println("songs = ", songs)
 		if len(songs) == 0 {
 			continue
 		}
@@ -243,10 +244,10 @@ func getSongFromList(games []models.GameData) models.SongData {
 
 		//Check if file exists and open
 		openFile, err := os.Open(song.Path)
-		log.Println("game.Path+song.FileName: ", game.Path+song.FileName)
-		log.Println("song.Path: ", song.Path)
-		log.Println("game.Path+song.FileName != song.Path: ", game.Path+song.FileName != song.Path)
-		if err != nil || game.Path+song.FileName != song.Path {
+		//log.Println("game.Path+song.FileName: ", game.Path+song.FileName)
+		//log.Println("song.Path: ", song.Path)
+		//log.Println("game.Path+song.FileName != song.Path: ", game.Path+song.FileName != song.Path)
+		if err != nil || game.Path+song.FileName != song.Path || strings.HasSuffix(song.FileName, ".wav") {
 			//File not found
 			db.RemoveBrokenSong(song)
 			log.Println("Song not found, song '" + song.SongName + "' deleted from game '" + game.GameName + "' FileName: " + song.FileName)

pkg/server/sync.go

@@ -10,9 +10,11 @@ import (
 	"sort"
 	"strconv"
 	"strings"
+	"sync"
 )
 
-// SyncGames TODO: Make sync concurrent
+var wg sync.WaitGroup
+
 func SyncGames() {
 	host := os.Getenv("DB_HOST")
 	var dir string
@@ -33,33 +35,66 @@ func SyncGames() {
 	}
 
 	for _, file := range files {
-		if file.IsDir() && !contains(foldersToSkip, file.Name()) {
-			fmt.Println(file.Name())
-			path := dir + file.Name() + "/"
-			fmt.Println(path)
+		syncGame(file, foldersToSkip, dir)
+	}
+}
 
-			entries, err := os.ReadDir(path)
+func SyncGamesQuick() {
+	host := os.Getenv("DB_HOST")
+	var dir string
+	if host != "" {
+		dir = "/sorted/"
+	} else {
+		dir = "/Users/sebastian/Resilio Sync/Sorterat_test/"
+	}
+	fmt.Printf("dir: %s\n", dir)
+	foldersToSkip := []string{".sync", "dist", "old"}
+	fmt.Println(foldersToSkip)
+	db.SetGameDeletionDate()
+	checkBrokenSongs()
+
+	files, err := os.ReadDir(dir)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for _, file := range files {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			syncGame(file, foldersToSkip, dir)
+		}()
+	}
+	wg.Wait()
+}
+
+func syncGame(file os.DirEntry, foldersToSkip []string, dir string) {
+	if file.IsDir() && !contains(foldersToSkip, file.Name()) {
+		fmt.Println(file.Name())
+		path := dir + file.Name() + "/"
+		fmt.Println(path)
+
+		entries, err := os.ReadDir(path)
+		if err != nil {
+			log.Println(err)
+		}
+		id := -1
+		for _, entry := range entries {
+			fileInfo, err := entry.Info()
 			if err != nil {
 				log.Println(err)
 			}
-			id := -1
-			for _, entry := range entries {
-				fileInfo, err := entry.Info()
-				if err != nil {
-					log.Println(err)
-				}
-				id = getIdFromFile(fileInfo)
-				if id != -1 {
-					break
-				}
-			}
-			if id == -1 {
-				addNewGame(file.Name(), path)
-			} else {
-				checkIfChanged(id, file.Name(), path)
-				checkSongs(path, id)
+			id = getIdFromFile(fileInfo)
+			if id != -1 {
+				break
 			}
 		}
+		if id == -1 {
+			addNewGame(file.Name(), path)
+		} else {
+			checkIfChanged(id, file.Name(), path)
+			checkSongs(path, id)
+		}
 	}
 }
 
@@ -160,7 +195,7 @@ func checkBrokenSongs() {
 }
 
 func isSong(entry fs.FileInfo) bool {
-	return !entry.IsDir() && strings.HasSuffix(entry.Name(), ".mp3") || strings.HasSuffix(entry.Name(), ".wav")
+	return !entry.IsDir() && strings.HasSuffix(entry.Name(), ".mp3")
 }
 
 func isCoverImage(entry fs.FileInfo) bool {