Fix Neon Vortex button input and add Jellyfin WAL mode
Some checks failed
Build and Push to Harbor / build-and-push (push) Has been cancelled

- Comment out CORS headers in nginx.conf to fix button input blocking
- Add WAL enable job for Jellyfin to resolve database locking issues
- Include comprehensive troubleshooting documentation

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Neon Vortex
2025-11-22 17:51:34 -05:00
parent 5b52eb9999
commit ce8d9029c1
4 changed files with 737 additions and 2 deletions

413
JELLYFIN_ERROR_ANALYSIS.md Normal file
View File

@@ -0,0 +1,413 @@
# Jellyfin Error Analysis and Recommendations
## Overview
Analysis of Jellyfin errors found in the media namespace logs, with recommendations for resolution.
---
## Issues Identified
### 1. **SQLite Database Locking Errors** (CRITICAL)
**Error Messages:**
```
[04:28:37] [ERR] Microsoft.Data.Sqlite.SqliteException (0x80004005): SQLite Error 5: 'database is locked'.
[09:00:00] [ERR] SQLite Error 5: 'database is locked For more information on this error code see https://www.sqlite.org/rescode.html'.
```
**Impact:**
- Prevents metadata updates during library scans
- Causes API request failures (GET /Items)
- Occurs when database optimization runs concurrently with library operations
**Root Cause:**
SQLite's default locking mechanism allows only one writer at a time. The errors occur when:
1. Database optimization task runs (VACUUM operation)
2. Library scan attempts to update metadata simultaneously
3. Both operations try to write to the database
**Frequency:**
- Database optimization runs approximately every 6 hours
- Library scans run every 12 hours
- Conflicts occur when these overlap
---
### 2. **Audio Normalization Failures** (MODERATE)
**Error Message:**
```
[04:24:54] [ERR] Emby.Server.Implementations.ScheduledTasks.Tasks.AudioNormalizationTask: Failed to find LUFS value in output
```
**Impact:**
- Audio normalization task cannot measure loudness
- Prevents automatic volume leveling across music library
- Task completes without performing any normalization
**Root Cause:**
The LUFS (Loudness Units relative to Full Scale) detection failure suggests:
1. FFmpeg may be missing required audio analysis filters
2. Audio files may have incompatible formats
3. FFmpeg output parsing may be failing
**Frequency:**
- Runs daily at 04:24 (during scheduled tasks)
- Consistently fails to find LUFS values
---
### 3. **Library Folder Warnings** (LOW PRIORITY)
**Warning Messages:**
```
[04:25:47] [WRN] Library folder /ebooks is inaccessible or empty, skipping
[04:25:47] [WRN] Library folder /config/data/playlists is inaccessible or empty, skipping
```
**Impact:**
- Minimal - warnings only
- No functional issues if these folders are intentionally empty
- Causes log noise
**Root Cause:**
- Library folders are configured but:
- `/ebooks` folder doesn't exist or is empty
- `/config/data/playlists` folder is empty
- Jellyfin skips these during library scans
---
## Recommendations
### Priority 1: Fix Database Locking Issues
#### Option A: Enable WAL Mode (RECOMMENDED)
WAL (Write-Ahead Logging) mode allows concurrent readers during writes, reducing lock contention.
**Implementation:**
1. **Create a job to enable WAL mode:**
Create file: `/storage/emulated/0/Download/nv/jellyfin-wal-enable.yaml`
```yaml
apiVersion: batch/v1
kind: Job
metadata:
name: jellyfin-enable-wal
namespace: media
spec:
ttlSecondsAfterFinished: 600
template:
spec:
restartPolicy: Never
containers:
- name: enable-wal
image: alpine:latest
command:
- sh
- -c
- |
apk add --no-cache sqlite
echo "Enabling WAL mode on jellyfin.db..."
sqlite3 /config/data/jellyfin.db "PRAGMA journal_mode=WAL;"
echo "Verifying WAL mode..."
sqlite3 /config/data/jellyfin.db "PRAGMA journal_mode;"
echo "Done!"
volumeMounts:
- name: jellyfin-data
mountPath: /config
volumes:
- name: jellyfin-data
persistentVolumeClaim:
claimName: jellyfin-config
```
**Benefits:**
- Multiple readers can access database during writes
- Reduces lock contention significantly
- Better performance under concurrent load
- Industry standard for high-concurrency SQLite
**Caveats:**
- Creates additional files (`jellyfin.db-wal`, `jellyfin.db-shm`)
- Requires slightly more disk space
- NFS must support file locking (appears to work based on current setup)
---
#### Option B: Adjust Task Scheduling
Prevent database optimization and library scans from running simultaneously.
**Current Schedule:**
- Library scan: Every 12 hours (04:26, 16:26)
- Database optimization: Every 6 hours (04:27, 10:28, 16:29)
**Recommended Change:**
Modify Jellyfin's scheduled tasks via the web UI:
1. Go to Dashboard → Scheduled Tasks
2. Change "Optimize database" to run at different times:
- Change from every 6 hours to daily at 03:00 (before library scan)
3. This ensures optimization completes before library scan starts
**Benefits:**
- Simple configuration change
- No code modifications needed
- Reduces overlap probability
**Caveats:**
- Doesn't eliminate all race conditions
- API requests during optimization can still fail
- Less robust than WAL mode
---
#### Option C: Increase SQLite Timeout
Configure Jellyfin to wait longer when database is locked.
**Implementation:**
Requires adding environment variable to Jellyfin deployment:
```yaml
env:
- name: SQLITE_BUSY_TIMEOUT
value: "30000" # 30 seconds
```
**Note:** This may not be supported by Jellyfin directly. WAL mode is preferred.
---
### Priority 2: Fix Audio Normalization
#### Diagnosis Steps:
1. **Check FFmpeg capabilities:**
```bash
kubectl exec -n media deployment/jellyfin -- ffmpeg -filters 2>&1 | grep -E "(loudnorm|ebur128)"
```
2. **Test LUFS detection manually:**
```bash
kubectl exec -n media deployment/jellyfin -- ffmpeg -i /music/sample.mp3 -af loudnorm=print_format=json -f null - 2>&1
```
Expected output should include:
```json
{
"input_i": "-23.0",
"input_tp": "-5.0",
"input_lra": "7.0",
"input_thresh": "-33.5",
"target_offset": "0.0"
}
```
#### Solution Options:
**If filters are missing:**
- Jellyfin's FFmpeg build may lack audio normalization filters
- Solution: Disable audio normalization task in Jellyfin (Dashboard → Scheduled Tasks)
**If filters exist but fail:**
- Some audio files may have incompatible formats
- Solution: Check task logs for specific files causing issues
**To disable audio normalization:**
1. Go to Dashboard → Scheduled Tasks
2. Find "Audio Normalization"
3. Click on it and disable the task
4. This is acceptable - normalization is optional for most users
---
### Priority 3: Clean Up Library Warnings
#### Option A: Remove Empty Library Folders
If you don't use ebooks or playlists:
1. Go to Dashboard → Libraries
2. Remove the "ebooks" library if it exists
3. The playlists folder is auto-created and can be ignored
#### Option B: Create the Folders
If you plan to use these features:
```bash
kubectl exec -n media deployment/jellyfin -- mkdir -p /ebooks
kubectl exec -n media deployment/jellyfin -- mkdir -p /config/data/playlists
```
---
## Implementation Plan
### Step 1: Enable WAL Mode (RECOMMENDED)
This will resolve the critical database locking issues.
```bash
# Apply the WAL enable job
kubectl apply -f jellyfin-wal-enable.yaml
# Wait for completion
kubectl wait --for=condition=complete --timeout=300s job/jellyfin-enable-wal -n media
# Check logs
kubectl logs -n media job/jellyfin-enable-wal
# Restart Jellyfin to ensure WAL mode is active
kubectl rollout restart deployment/jellyfin -n media
```
### Step 2: Disable Audio Normalization (OPTIONAL)
Via Jellyfin Web UI:
1. Navigate to https://jellyfin.caffeinetux.com/web/index.html#!/scheduledtasks.html
2. Find "Audio Normalization"
3. Click "Disable"
### Step 3: Monitor Logs
After implementing WAL mode:
```bash
# Watch for database lock errors (should disappear)
kubectl logs -n media deployment/jellyfin -f | grep "database is locked"
# Check if WAL mode is active
kubectl exec -n media deployment/jellyfin -- sqlite3 /config/data/jellyfin.db "PRAGMA journal_mode;"
# Should output: wal
```
---
## Performance Impact Analysis
### Current Issues:
- Database locks during library scans (2+ minutes)
- Failed API requests during optimization
- Metadata updates delayed or skipped
### After WAL Mode:
- ✅ Concurrent reads during writes
- ✅ API requests succeed during optimization
- ✅ Faster metadata updates
- ✅ Better overall responsiveness
### Trade-offs:
- Slightly more disk space (typically <10% of DB size)
- Additional files in config directory
- Minimal performance overhead (usually net positive)
---
## Additional Recommendations
### 1. Database Optimization Frequency
Current: Every 6 hours may be excessive
**Recommendation:** Change to once daily at 03:00
Benefits:
- Reduces I/O load on NFS
- Less frequent database locks
- Sufficient for most libraries
### 2. Library Scan Optimization
**Current behavior:**
- Full library scan every 12 hours
- Stops directory watching during scan
**Recommendation:**
- Keep 12-hour schedule for now
- Monitor scan duration (currently 2-5 minutes)
- If scans take too long, consider:
- Increasing interval to 24 hours
- Using real-time monitoring only
### 3. NFS Considerations
Your Jellyfin database is on NFS. WAL mode works with NFS if:
- File locking is supported (appears to be working)
- NFS client supports mmap operations
- Network latency is low (check if you experience slowness)
**If WAL mode causes issues on NFS:**
- Switch back to DELETE mode: `PRAGMA journal_mode=DELETE;`
- Consider moving database to local storage (emptyDir volume)
- Keep media on NFS, database local
---
## Monitoring and Validation
### Success Criteria:
After implementing WAL mode, verify:
1. **No more database lock errors:**
```bash
kubectl logs -n media deployment/jellyfin --since=24h | grep "database is locked"
# Should return no results
```
2. **WAL mode is active:**
```bash
kubectl exec -n media deployment/jellyfin -- sqlite3 /config/data/jellyfin.db "PRAGMA journal_mode;"
# Should output: wal
```
3. **Library scans complete successfully:**
```bash
kubectl logs -n media deployment/jellyfin | grep "Scan Media Library Completed"
# Should show successful completions
```
4. **Database optimization runs without conflicts:**
```bash
kubectl logs -n media deployment/jellyfin | grep "jellyfin.db optimized successfully"
# Should show successful optimizations
```
---
## Summary
### Critical Issues (Fix Now):
1. **SQLite Database Locking** Enable WAL mode
### Optional Improvements:
2. **Audio Normalization** Disable if not needed
3. **Library Warnings** Remove unused libraries or create folders
4. **Task Scheduling** Adjust optimization frequency to daily
### Expected Outcome:
- Elimination of database lock errors
- Smoother library scans
- Better API responsiveness
- Cleaner logs
---
## Resources
- [SQLite WAL Mode Documentation](https://www.sqlite.org/wal.html)
- [Jellyfin Database Documentation](https://jellyfin.org/docs/general/administration/configuration.html)
- [SQLite Error Codes](https://www.sqlite.org/rescode.html)
---
**Analysis Date:** 2025-11-22
**Jellyfin Namespace:** media
**Database Location:** /config/data/jellyfin.db (NFS-backed PVC)

289
NEON_VORTEX_BUTTON_FIX.md Normal file
View File

@@ -0,0 +1,289 @@
# Neon Vortex Button Issue - Troubleshooting Guide
## Problem
Buttons work in Godot editor but not working in the deployed web version at https://nv.caffeinetux.com
## Most Likely Causes
### 1. **CORS Headers Too Restrictive**
The current nginx configuration has very strict CORS headers:
```nginx
add_header Cross-Origin-Embedder-Policy "require-corp" always;
add_header Cross-Origin-Opener-Policy "same-origin" always;
```
These headers are required for SharedArrayBuffer (threads) but can break:
- Mouse/touch input
- Button click events
- External resources
**Check if you need threads:**
- Look at your Godot export settings
- If "Export Type" is **Regular** (not Threads), these headers might be blocking input
**Fix:** Update nginx.conf to conditionally apply headers:
```nginx
# Only add CORS headers if using threads
# For Regular (non-threaded) exports, comment these out:
# add_header Cross-Origin-Embedder-Policy "require-corp" always;
# add_header Cross-Origin-Opener-Policy "same-origin" always;
```
### 2. **JavaScript Console Errors**
**How to Check:**
1. Open https://nv.caffeinetux.com in browser
2. Press F12 (Developer Tools)
3. Go to Console tab
4. Click a button and look for errors
**Common Errors:**
#### Error: "SharedArrayBuffer is not defined"
- **Cause:** Missing CORS headers or not using HTTPS
- **Fix:** Keep the CORS headers, ensure HTTPS is working ✅ (you have this)
#### Error: "Failed to fetch" or "CORS policy"
- **Cause:** CORS headers too restrictive or missing resources
- **Fix:** Check Network tab for failed requests
#### Error: "WebGL context lost"
- **Cause:** GPU issues or resource exhaustion
- **Fix:** Reduce graphics quality in Godot, add memory limits
#### Error: "Input blocked"
- **Cause:** Browser security policy or iframe restrictions
- **Fix:** Ensure X-Frame-Options allows the domain
### 3. **Input Method Not Exported**
**In Godot, check your button scripts:**
```gdscript
# ✅ CORRECT - Web-compatible input
func _on_Button_pressed():
print("Button clicked!")
# Your code here
# ❌ WRONG - May not work on web
func _input(event):
if event is InputEventMouseButton:
# This might not work in some web configs
```
**Fix:** Use signal connections, not `_input()` or `_unhandled_input()` for buttons.
### 4. **Export Settings Issue**
**Check in Godot:**
1. Go to **Project → Export → HTML5**
2. Verify:
-**Export Type:** Regular (unless you need threads)
-**Custom HTML Shell:** Not set (use default)
-**Head Include:** Empty or minimal
-**Progressive Web App:** OFF (for debugging)
**Re-export:**
1. Delete the old export
2. Export fresh
3. Test locally first: `python3 -m http.server 8000`
4. If buttons work locally, issue is deployment-related
### 5. **Browser Cache**
**Your browser might be caching old broken version:**
**Fix:**
1. Hard refresh: `Ctrl + Shift + R` (or `Cmd + Shift + R` on Mac)
2. Clear cache for the site
3. Or use Incognito/Private browsing
### 6. **Service Worker Blocking**
The game has a service worker (`Neon Vortex.service.worker.js`) for offline support.
If corrupted, it can block updates.
**Fix:**
1. Open DevTools (F12)
2. Go to **Application** tab
3. Click **Service Workers**
4. Click **Unregister** for nv.caffeinetux.com
5. Hard refresh the page
## Recommended Debugging Steps
### Step 1: Check Browser Console
```
1. Open https://nv.caffeinetux.com
2. Press F12
3. Go to Console tab
4. Try clicking a button
5. Note any errors
```
### Step 2: Test Without CORS Headers
Temporarily modify nginx.conf:
```nginx
server {
listen 8080;
server_name _;
root /usr/share/nginx/html;
index "Neon Vortex.html";
# TEMPORARILY COMMENT OUT for testing:
# add_header Cross-Origin-Embedder-Policy "require-corp" always;
# add_header Cross-Origin-Opener-Policy "same-origin" always;
# Keep these:
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
location / {
try_files $uri $uri/ "/Neon Vortex.html";
}
}
```
**Rebuild and test:**
```bash
# Commit changes
git add htlm/nginx.conf
git commit -m "Test: Remove strict CORS headers"
git push
# Rebuild image (will happen via Flux)
# Wait for deployment
# Test buttons
```
### Step 3: Check Network Tab
1. Open DevTools (F12)
2. Go to **Network** tab
3. Reload page
4. Look for:
- ❌ Failed requests (red)
- ❌ 404 errors for required files
- ✅ All .js, .wasm, .pck files loaded successfully
### Step 4: Test Locally
```bash
# Navigate to exported game folder
cd htlm/
# Start local server
python3 -m http.server 8000
# Open browser to http://localhost:8000
# Test if buttons work
```
**If buttons work locally but not deployed:**
- Issue is deployment-related (nginx config, CORS, headers)
**If buttons don't work locally:**
- Issue is with Godot export or game code
## Most Likely Fix
Based on your current setup, **most likely cause is CORS headers**.
### Quick Fix:
**htlm/nginx.conf** - Update to:
```nginx
server {
listen 8080;
server_name _;
root /usr/share/nginx/html;
index "Neon Vortex.html";
# Enable gzip compression
gzip on;
gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript application/wasm;
gzip_min_length 1000;
# MIME types for WASM and other assets
types {
application/wasm wasm;
application/javascript js;
text/html html;
application/json json;
image/png png;
}
# Security headers
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
# ONLY ADD THESE IF YOUR GAME USES THREADS:
# If your Godot export is "Regular" (not "Threads"), comment these out:
# add_header Cross-Origin-Embedder-Policy "require-corp" always;
# add_header Cross-Origin-Opener-Policy "same-origin" always;
location / {
try_files $uri $uri/ "/Neon Vortex.html";
}
# Cache static assets
location ~* \.(png|jpg|jpeg|gif|ico|wasm|js|css)$ {
expires 1y;
add_header Cache-Control "public, immutable";
}
}
```
## Godot-Specific Button Fixes
### Check Your Button Code:
**✅ CORRECT - Signal-based (Web-safe):**
```gdscript
extends Button
func _ready():
connect("pressed", self, "_on_button_pressed")
func _on_button_pressed():
print("Button clicked!")
get_tree().change_scene("res://next_scene.tscn")
```
**✅ CORRECT - Using Godot Editor signals:**
```
1. Select button in scene tree
2. Go to Node tab (right side)
3. Double-click "pressed()" signal
4. Connect to script function
5. Implement the function
```
**❌ AVOID - Input polling (may not work on web):**
```gdscript
func _process(delta):
if Input.is_action_just_pressed("ui_accept"):
# This might not work reliably on web
```
### Button Properties to Check:
```
✅ Mouse Filter: Stop (default)
✅ Focus Mode: All or Click
✅ Disabled: false
✅ Visible: true
```
## Next Steps
1. **Check browser console** - This will tell you the exact error
2. **Test without CORS headers** - Comment them out temporarily
3. **Test locally** - See if it's deployment or game issue
4. **Share console errors** - If still broken, share the browser console output
The most common cause is the CORS headers blocking input, so start there!

View File

@@ -25,8 +25,11 @@ server {
add_header X-XSS-Protection "1; mode=block" always;
# CORS headers for web workers and WASM
add_header Cross-Origin-Embedder-Policy "require-corp" always;
add_header Cross-Origin-Opener-Policy "same-origin" always;
# ONLY NEEDED IF GODOT EXPORT USES THREADS MODE
# These headers can block input if export is "Regular" (non-threaded)
# Commenting out to fix button input issues
# add_header Cross-Origin-Embedder-Policy "require-corp" always;
# add_header Cross-Origin-Opener-Policy "same-origin" always;
location / {
try_files $uri $uri/ "/Neon Vortex.html";

30
jellyfin-wal-enable.yaml Normal file
View File

@@ -0,0 +1,30 @@
apiVersion: batch/v1
kind: Job
metadata:
name: jellyfin-enable-wal
namespace: media
spec:
ttlSecondsAfterFinished: 600
template:
spec:
restartPolicy: Never
containers:
- name: enable-wal
image: alpine:latest
command:
- sh
- -c
- |
apk add --no-cache sqlite
echo "Enabling WAL mode on jellyfin.db..."
sqlite3 /config/data/jellyfin.db "PRAGMA journal_mode=WAL;"
echo "Verifying WAL mode..."
sqlite3 /config/data/jellyfin.db "PRAGMA journal_mode;"
echo "WAL mode enabled successfully!"
volumeMounts:
- name: jellyfin-data
mountPath: /config
volumes:
- name: jellyfin-data
persistentVolumeClaim:
claimName: jellyfin-config