621 lines
20 KiB
Markdown
621 lines
20 KiB
Markdown
# 0.11.7 — Stale Data Cleanup + FileBrowser Sync + UI Title Fix
|
|
|
|
## Summary
|
|
|
|
Three changes in this release:
|
|
1. **Stale data cleanup** — After migration, option to delete data from the previous storage location
|
|
2. **FileBrowser sync after migration** — Trigger `syncFileBrowserMounts()` after successful migration
|
|
3. **UI title fix** — Deploy page shows "Beállítások" instead of "Telepítés" for already-deployed apps
|
|
|
|
---
|
|
|
|
## 1. Stale Data Cleanup
|
|
|
|
### Concept
|
|
|
|
After migrating an app (e.g. Immich from `hdd_placeholder` → `hdd_1`), the old data remains as a safety backup. We need to:
|
|
- Detect stale data on non-active storage paths
|
|
- Show it on the deploy (settings) page
|
|
- Allow deletion with proper warnings
|
|
- Also offer deletion right after migration completes
|
|
|
|
### Files Modified
|
|
|
|
| File | Change |
|
|
|------|--------|
|
|
| `internal/web/handlers.go` | Add `findStaleStorageData()`, `staleDataCleanupHandler()` |
|
|
| `internal/web/server.go` | Register new route |
|
|
| `internal/web/templates/deploy.html` | Show stale data card with delete button |
|
|
| `internal/web/templates/migrate.html` | Add delete button to migration-done card |
|
|
| `internal/api/router.go` | Add `DELETE /api/stacks/{name}/stale-data` route |
|
|
|
|
---
|
|
|
|
## 2. FileBrowser Sync After Migration
|
|
|
|
### Files Modified
|
|
|
|
| File | Change |
|
|
|------|--------|
|
|
| `internal/web/handlers.go` | Add `syncFileBrowserMounts()` call after successful migration |
|
|
|
|
---
|
|
|
|
## 3. UI Title Fix
|
|
|
|
### Files Modified
|
|
|
|
| File | Change |
|
|
|------|--------|
|
|
| `internal/web/handlers.go` | Dynamic page title based on `alreadyDeployed` |
|
|
| `internal/web/templates/deploy.html` | Dynamic `<h2>` title |
|
|
|
|
---
|
|
|
|
## Detailed Changes
|
|
|
|
### `internal/web/handlers.go`
|
|
|
|
#### Change 1: Dynamic page title (Task 3)
|
|
|
|
```go
|
|
// BEFORE (line ~13105):
|
|
data := s.baseData("deploy", meta.DisplayName+" — Telepítés")
|
|
|
|
// AFTER:
|
|
pageTitle := meta.DisplayName + " — Telepítés"
|
|
if alreadyDeployed {
|
|
pageTitle = meta.DisplayName + " — Beállítások"
|
|
}
|
|
data := s.baseData("deploy", pageTitle)
|
|
```
|
|
|
|
#### Change 2: Add stale data to deploy page context (Task 1)
|
|
|
|
In `deployHandler`, after the existing `storageInfo` block (after line ~13135), add:
|
|
|
|
```go
|
|
// Stale data from previous migrations (only for deployed apps with HDD data)
|
|
if alreadyDeployed {
|
|
staleData := s.findStaleStorageData(name)
|
|
if len(staleData) > 0 {
|
|
data["StaleData"] = staleData
|
|
}
|
|
}
|
|
```
|
|
|
|
#### Change 3: Add `findStaleStorageData()` function (Task 1)
|
|
|
|
Add after `storageInfoForStack()`:
|
|
|
|
```go
|
|
// StaleStorageData describes leftover data on a non-active storage path.
|
|
type StaleStorageData struct {
|
|
Path string // e.g., "/mnt/hdd_placeholder"
|
|
Label string // e.g., "Külső tárhely (hdd_placeholder)"
|
|
Mounts []string // host-side paths with data
|
|
SizeHuman string // e.g., "48 MB"
|
|
SizeBytes int64
|
|
}
|
|
|
|
// findStaleStorageData detects leftover app data on non-active storage paths.
|
|
// This happens after migration: the old data stays on the previous storage path.
|
|
func (s *Server) findStaleStorageData(stackName string) []StaleStorageData {
|
|
appCfg := s.stackMgr.LoadAppConfigByName(stackName)
|
|
if appCfg == nil {
|
|
return nil
|
|
}
|
|
currentHDDPath := appCfg.Env["HDD_PATH"]
|
|
if currentHDDPath == "" {
|
|
return nil
|
|
}
|
|
|
|
stack, ok := s.stackMgr.GetStack(stackName)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
var result []StaleStorageData
|
|
|
|
// Check all registered storage paths except the current one
|
|
for _, sp := range s.settings.GetStoragePaths() {
|
|
if sp.Path == currentHDDPath {
|
|
continue
|
|
}
|
|
|
|
// Use ParseComposeHDDMounts to find what dirs WOULD exist on this path
|
|
mounts := stacks.ParseComposeHDDMounts(stack.ComposePath, sp.Path)
|
|
if len(mounts) == 0 {
|
|
continue
|
|
}
|
|
|
|
// Check which mounts actually have data
|
|
var existingMounts []string
|
|
var totalSize int64
|
|
for _, m := range mounts {
|
|
info, err := os.Stat(m)
|
|
if err != nil || !info.IsDir() {
|
|
continue
|
|
}
|
|
size := dirSizeInt64(m)
|
|
if size > 0 {
|
|
existingMounts = append(existingMounts, m)
|
|
totalSize += size
|
|
}
|
|
}
|
|
|
|
if len(existingMounts) == 0 {
|
|
continue
|
|
}
|
|
|
|
label := sp.Label
|
|
if label == "" {
|
|
label = settings.InferStorageLabel(sp.Path)
|
|
}
|
|
|
|
result = append(result, StaleStorageData{
|
|
Path: sp.Path,
|
|
Label: label,
|
|
Mounts: existingMounts,
|
|
SizeHuman: dirSizeBytesHuman(totalSize),
|
|
SizeBytes: totalSize,
|
|
})
|
|
}
|
|
|
|
return result
|
|
}
|
|
```
|
|
|
|
#### Change 4: Add stale data cleanup API handler (Task 1)
|
|
|
|
Add to storage API handler switch in `storageAPIHandler()`:
|
|
|
|
```go
|
|
case path == "/api/storage/stale-cleanup" && r.Method == http.MethodPost:
|
|
s.staleDataCleanupHandler(w, r)
|
|
```
|
|
|
|
Add the handler function:
|
|
|
|
```go
|
|
// staleDataCleanupHandler handles POST /api/storage/stale-cleanup.
|
|
// Deletes leftover app data from a previous storage path after migration.
|
|
func (s *Server) staleDataCleanupHandler(w http.ResponseWriter, r *http.Request) {
|
|
var req struct {
|
|
StackName string `json:"stack_name"`
|
|
StalePath string `json:"stale_path"` // the old storage root, e.g., "/mnt/hdd_placeholder"
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
jsonError(w, "Érvénytelen kérés", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if req.StackName == "" || req.StalePath == "" {
|
|
jsonError(w, "Hiányos paraméterek", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// Verify the app exists and is deployed
|
|
stack, ok := s.stackMgr.GetStack(req.StackName)
|
|
if !ok {
|
|
jsonError(w, "Alkalmazás nem található: "+req.StackName, http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
appCfg := s.stackMgr.LoadAppConfigByName(req.StackName)
|
|
if appCfg == nil || !appCfg.Deployed {
|
|
jsonError(w, "Az alkalmazás nincs telepítve", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
currentHDDPath := appCfg.Env["HDD_PATH"]
|
|
if currentHDDPath == "" {
|
|
jsonError(w, "Az alkalmazásnak nincs HDD_PATH beállítva", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// SAFETY: StalePath must NOT be the current HDD_PATH
|
|
if req.StalePath == currentHDDPath {
|
|
jsonError(w, "Az aktív tárhely adatai nem törölhetők! Ez az alkalmazás aktuális adattárolója.", http.StatusForbidden)
|
|
return
|
|
}
|
|
|
|
// SAFETY: StalePath must be a registered storage path
|
|
found := false
|
|
for _, sp := range s.settings.GetStoragePaths() {
|
|
if sp.Path == req.StalePath {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
jsonError(w, "A megadott útvonal nem regisztrált adattároló", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// Find mounts to delete
|
|
mounts := stacks.ParseComposeHDDMounts(stack.ComposePath, req.StalePath)
|
|
if len(mounts) == 0 {
|
|
jsonError(w, "Nem találhatók törlendő adatok", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
// Protected paths check
|
|
protected := protectedHDDPaths(req.StalePath)
|
|
|
|
var deleted []string
|
|
var errors []string
|
|
var totalFreed int64
|
|
|
|
for _, mountPath := range mounts {
|
|
cleanPath := filepath.Clean(mountPath)
|
|
|
|
// Safety: never delete protected top-level dirs
|
|
if protected != nil && protected[cleanPath] {
|
|
s.logger.Printf("[WARN] Refusing to delete protected HDD path: %s", cleanPath)
|
|
errors = append(errors, fmt.Sprintf("Védett útvonal, nem törölhető: %s", cleanPath))
|
|
continue
|
|
}
|
|
|
|
// Verify it actually exists and has data
|
|
info, err := os.Stat(cleanPath)
|
|
if err != nil || !info.IsDir() {
|
|
continue
|
|
}
|
|
|
|
size := dirSizeInt64(cleanPath)
|
|
|
|
if err := os.RemoveAll(cleanPath); err != nil {
|
|
s.logger.Printf("[ERROR] Failed to remove stale data %s: %v", cleanPath, err)
|
|
errors = append(errors, fmt.Sprintf("Törlés sikertelen: %s — %v", cleanPath, err))
|
|
} else {
|
|
s.logger.Printf("[INFO] Removed stale data: %s (%s) for stack %s", cleanPath, dirSizeBytesHuman(size), req.StackName)
|
|
deleted = append(deleted, cleanPath)
|
|
totalFreed += size
|
|
}
|
|
}
|
|
|
|
if len(deleted) == 0 && len(errors) > 0 {
|
|
jsonError(w, "Törlés sikertelen: "+strings.Join(errors, "; "), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
jsonResponse(w, map[string]interface{}{
|
|
"ok": true,
|
|
"deleted": deleted,
|
|
"freed_human": dirSizeBytesHuman(totalFreed),
|
|
"errors": errors,
|
|
})
|
|
}
|
|
```
|
|
|
|
Note: `protectedHDDPaths` is in `internal/stacks/delete.go` — you may need to either export it or duplicate the logic. Since it's a simple function, the cleanest approach is to either:
|
|
- Export it from stacks package (`ProtectedHDDPaths`)
|
|
- Or inline the same logic in handlers.go
|
|
|
|
For simplicity, since the web package already imports stacks, export it:
|
|
|
|
In `internal/stacks/delete.go`:
|
|
```go
|
|
// BEFORE:
|
|
func protectedHDDPaths(hddPath string) map[string]bool {
|
|
|
|
// AFTER:
|
|
func ProtectedHDDPaths(hddPath string) map[string]bool {
|
|
```
|
|
|
|
And update the existing call in `DeleteStack`:
|
|
```go
|
|
// BEFORE:
|
|
protected := protectedHDDPaths(hddPath)
|
|
|
|
// AFTER:
|
|
protected := ProtectedHDDPaths(hddPath)
|
|
```
|
|
|
|
Then in handlers.go, the call becomes:
|
|
```go
|
|
protected := stacks.ProtectedHDDPaths(req.StalePath)
|
|
```
|
|
|
|
#### Change 5: Sync FileBrowser after migration (Task 2)
|
|
|
|
In `storageMigrateAPIHandler`, in the goroutine where migration runs, add FileBrowser sync after success:
|
|
|
|
```go
|
|
go func() {
|
|
progressCh := make(chan storage.MigrateProgress, 64)
|
|
go func() {
|
|
for p := range progressCh {
|
|
job.appendMigProg(p)
|
|
}
|
|
}()
|
|
|
|
if err := storage.MigrateAppData(migrReq, stopFn, startFn, updateFn, progressCh); err != nil {
|
|
s.logger.Printf("[ERROR] Migration failed: stack=%s: %v", req.StackName, err)
|
|
} else {
|
|
s.logger.Printf("[INFO] Migration complete: stack=%s → %s", req.StackName, req.TargetPath)
|
|
// Sync FileBrowser mounts (storage paths may now have new app data)
|
|
go s.syncFileBrowserMounts()
|
|
}
|
|
close(progressCh)
|
|
}()
|
|
```
|
|
|
|
### `internal/web/templates/deploy.html`
|
|
|
|
#### Change 1: Dynamic title (Task 3)
|
|
|
|
```html
|
|
<!-- BEFORE (line 15717): -->
|
|
<h2>{{.Meta.DisplayName}} — Telepítés</h2>
|
|
|
|
<!-- AFTER: -->
|
|
<h2>{{.Meta.DisplayName}} — {{if .AlreadyDeployed}}Beállítások{{else}}Telepítés{{end}}</h2>
|
|
```
|
|
|
|
#### Change 2: Stale data card (Task 1)
|
|
|
|
Add after the StorageInfo block (after the `{{end}}` that closes `{{if .StorageInfo}}`) and before the closing `{{end}}` of `{{if .AlreadyDeployed}}`:
|
|
|
|
```html
|
|
{{if .StaleData}}
|
|
<div class="deploy-stale-data">
|
|
<h4>🗑️ Korábbi adatok</h4>
|
|
<p class="form-hint" style="margin-bottom:1rem">
|
|
Az alkalmazás adatainak másolata megtalálható egy másik tárolón is.
|
|
Ez általában áthelyezés után marad hátra.
|
|
</p>
|
|
{{range .StaleData}}
|
|
<div class="stale-data-item">
|
|
<div class="settings-grid" style="margin-bottom:.75rem">
|
|
<div class="settings-row">
|
|
<span class="settings-label">Tárhely</span>
|
|
<span class="settings-value">{{.Label}} <span class="mono" style="color:var(--text-secondary)">({{.Path}})</span></span>
|
|
</div>
|
|
<div class="settings-row">
|
|
<span class="settings-label">Méret</span>
|
|
<span class="settings-value mono">{{.SizeHuman}}</span>
|
|
</div>
|
|
<div class="settings-row">
|
|
<span class="settings-label">Mappák</span>
|
|
<span class="settings-value mono" style="font-size:.85rem">{{range .Mounts}}{{.}}<br>{{end}}</span>
|
|
</div>
|
|
</div>
|
|
<button class="btn btn-sm btn-danger" onclick="deleteStaleData('{{$.Meta.Slug}}', '{{.Path}}', this)">
|
|
🗑️ Korábbi adatok törlése
|
|
</button>
|
|
</div>
|
|
{{end}}
|
|
</div>
|
|
{{end}}
|
|
```
|
|
|
|
#### Change 3: Add stale data delete JS function
|
|
|
|
Add to the `<script>` section at the bottom of deploy.html:
|
|
|
|
```javascript
|
|
function deleteStaleData(stackName, stalePath, btn) {
|
|
if (!confirm('Biztosan törölni szeretnéd a korábbi adatokat?\n\nTárhely: ' + stalePath + '\n\n⚠️ Ez a művelet visszavonhatatlan!\nElőtte győződj meg róla, hogy az alkalmazás az új tárolóról megfelelően működik.')) {
|
|
return;
|
|
}
|
|
// Second confirmation
|
|
if (!confirm('UTOLSÓ FIGYELMEZTETÉS!\n\nA törlés visszavonhatatlan. Biztosan folytatod?')) {
|
|
return;
|
|
}
|
|
|
|
btn.disabled = true;
|
|
btn.textContent = 'Törlés folyamatban...';
|
|
|
|
fetch('/api/storage/stale-cleanup', {
|
|
method: 'POST',
|
|
headers: {'Content-Type': 'application/json'},
|
|
body: JSON.stringify({stack_name: stackName, stale_path: stalePath})
|
|
})
|
|
.then(function(r) { return r.json(); })
|
|
.then(function(data) {
|
|
if (!data.ok) {
|
|
alert('Hiba: ' + (data.error || 'Ismeretlen hiba'));
|
|
btn.disabled = false;
|
|
btn.textContent = '🗑️ Korábbi adatok törlése';
|
|
return;
|
|
}
|
|
var msg = '✅ Korábbi adatok törölve!\n\nFelszabadított hely: ' + (data.freed_human || '?');
|
|
if (data.errors && data.errors.length > 0) {
|
|
msg += '\n\n⚠️ Néhány hiba történt:\n' + data.errors.join('\n');
|
|
}
|
|
alert(msg);
|
|
// Remove the stale data card from DOM
|
|
var item = btn.closest('.stale-data-item');
|
|
if (item) item.remove();
|
|
// If no more stale items, remove the whole section
|
|
var container = document.querySelector('.deploy-stale-data');
|
|
if (container && container.querySelectorAll('.stale-data-item').length === 0) {
|
|
container.remove();
|
|
}
|
|
})
|
|
.catch(function(e) {
|
|
alert('Hálózati hiba: ' + e.message);
|
|
btn.disabled = false;
|
|
btn.textContent = '🗑️ Korábbi adatok törlése';
|
|
});
|
|
}
|
|
```
|
|
|
|
### `internal/web/templates/migrate.html`
|
|
|
|
#### Change: Add delete old data button to migration-done card (Task 1)
|
|
|
|
Replace the `migrate-done-card` div:
|
|
|
|
```html
|
|
<div class="settings-card" id="migrate-done-card" style="display:none">
|
|
<h3>✅ Adatáthelyezés kész!</h3>
|
|
<p style="margin-top:.75rem;color:var(--text-secondary)">
|
|
Az alkalmazás az új tárolóról fut.<br>
|
|
A régi adatok a korábbi helyen megmaradtak biztonsági másolatként.
|
|
</p>
|
|
<div class="alert alert-warning" style="margin-top:1rem">
|
|
<strong>Javasolt lépések:</strong>
|
|
<ol style="margin:.5rem 0 0 1rem;padding:0">
|
|
<li>Ellenőrizd, hogy az alkalmazás megfelelően működik</li>
|
|
<li>Győződj meg róla, hogy minden adat megtalálható</li>
|
|
<li>Ha minden rendben, törölheted a korábbi adatokat</li>
|
|
</ol>
|
|
</div>
|
|
<div style="margin-top:1.5rem;display:flex;gap:.75rem;flex-wrap:wrap">
|
|
<a href="/stacks/{{.Meta.Slug}}/deploy" class="btn btn-primary">Alkalmazások megtekintése</a>
|
|
<button id="migrate-delete-old-btn" class="btn btn-outline btn-danger" onclick="deleteOldMigrationData()" style="display:none">
|
|
🗑️ Korábbi adatok törlése
|
|
</button>
|
|
<a href="/settings" class="btn btn-outline">Beállítások</a>
|
|
</div>
|
|
</div>
|
|
```
|
|
|
|
Add to the `<script>` section, update `showMigDone()`:
|
|
|
|
```javascript
|
|
function showMigDone() {
|
|
document.getElementById('migrate-progress-card').style.display = 'none';
|
|
document.getElementById('migrate-done-card').style.display = 'block';
|
|
document.getElementById('migrate-done-card').scrollIntoView({behavior:'smooth'});
|
|
// Show the delete button (old data is at the source path)
|
|
document.getElementById('migrate-delete-old-btn').style.display = '';
|
|
}
|
|
|
|
function deleteOldMigrationData() {
|
|
var oldPath = '{{.CurrentHDDPath}}';
|
|
if (!confirm('Biztosan törölni szeretnéd a korábbi adatokat?\n\nTárhely: ' + oldPath + '\n\n⚠️ Ez a művelet visszavonhatatlan!\nElőtte győződj meg róla, hogy az alkalmazás az új tárolóról megfelelően működik.')) {
|
|
return;
|
|
}
|
|
if (!confirm('UTOLSÓ FIGYELMEZTETÉS!\n\nA törlés visszavonhatatlan. Biztosan folytatod?')) {
|
|
return;
|
|
}
|
|
|
|
var btn = document.getElementById('migrate-delete-old-btn');
|
|
btn.disabled = true;
|
|
btn.textContent = 'Törlés folyamatban...';
|
|
|
|
fetch('/api/storage/stale-cleanup', {
|
|
method: 'POST',
|
|
headers: {'Content-Type': 'application/json'},
|
|
body: JSON.stringify({stack_name: stackName, stale_path: oldPath})
|
|
})
|
|
.then(function(r) { return r.json(); })
|
|
.then(function(data) {
|
|
if (!data.ok) {
|
|
alert('Hiba: ' + (data.error || 'Ismeretlen hiba'));
|
|
btn.disabled = false;
|
|
btn.textContent = '🗑️ Korábbi adatok törlése';
|
|
return;
|
|
}
|
|
btn.textContent = '✅ Korábbi adatok törölve (' + (data.freed_human || '') + ')';
|
|
btn.classList.remove('btn-danger');
|
|
btn.classList.add('btn-outline');
|
|
btn.onclick = null;
|
|
})
|
|
.catch(function(e) {
|
|
alert('Hálózati hiba: ' + e.message);
|
|
btn.disabled = false;
|
|
btn.textContent = '🗑️ Korábbi adatok törlése';
|
|
});
|
|
}
|
|
```
|
|
|
|
### `internal/web/templates/style.css`
|
|
|
|
Add stale data styling:
|
|
|
|
```css
|
|
/* Stale data cleanup */
|
|
.deploy-stale-data {
|
|
background: var(--card-bg);
|
|
border: 1px solid var(--orange);
|
|
border-radius: var(--radius);
|
|
padding: 1.5rem;
|
|
margin-top: 1rem;
|
|
}
|
|
.deploy-stale-data h4 {
|
|
margin: 0 0 0.5rem 0;
|
|
color: var(--orange);
|
|
}
|
|
.stale-data-item {
|
|
padding: 1rem;
|
|
background: rgba(255, 165, 0, 0.05);
|
|
border-radius: var(--radius);
|
|
margin-bottom: 0.75rem;
|
|
}
|
|
.stale-data-item:last-child {
|
|
margin-bottom: 0;
|
|
}
|
|
.btn-danger {
|
|
background: var(--red);
|
|
color: white;
|
|
border-color: var(--red);
|
|
}
|
|
.btn-danger:hover {
|
|
opacity: 0.85;
|
|
}
|
|
```
|
|
|
|
### `internal/stacks/delete.go` — Export `protectedHDDPaths`
|
|
|
|
```go
|
|
// BEFORE:
|
|
func protectedHDDPaths(hddPath string) map[string]bool {
|
|
|
|
// AFTER:
|
|
func ProtectedHDDPaths(hddPath string) map[string]bool {
|
|
```
|
|
|
|
Update the call in `DeleteStack`:
|
|
```go
|
|
// BEFORE:
|
|
protected := protectedHDDPaths(hddPath)
|
|
|
|
// AFTER:
|
|
protected := ProtectedHDDPaths(hddPath)
|
|
```
|
|
|
|
---
|
|
|
|
## Changelog entry
|
|
|
|
```
|
|
- **0.11.7 — Stale Data Cleanup + FileBrowser Sync + UI Polish:**
|
|
- **Feature: Stale data cleanup** — After app data migration, the deploy/settings page now shows leftover data on previous storage paths with size info and a delete button. Two-step confirmation required before deletion. Protected paths (top-level storage, media, Dokumentumok, appdata) cannot be deleted. Also available immediately after migration on the migration-done page.
|
|
- **Fix: FileBrowser sync after migration** — `syncFileBrowserMounts()` now called after successful data migration, ensuring FileBrowser mounts reflect the current storage layout.
|
|
- **Fix: Deploy page title** — Already-deployed apps now show "Beállítások" (Settings) instead of "Telepítés" (Deploy) in both the page title and the `<h2>` heading.
|
|
- **Internal: Exported `ProtectedHDDPaths()`** from stacks package for reuse in web handlers.
|
|
- **Files modified (8):** `handlers.go`, `server.go`, `delete.go`, `deploy.html`, `migrate.html`, `style.css`, `router.go` (if adding route there, but actually it's in storageAPIHandler)
|
|
```
|
|
|
|
---
|
|
|
|
## Testing Checklist
|
|
|
|
1. **Stale data detection:**
|
|
- Deploy immich on hdd_placeholder
|
|
- Migrate to hdd_1
|
|
- Visit immich deploy/settings page → should show "Korábbi adatok" card with hdd_placeholder data size
|
|
- Delete the stale data → confirm both prompts → data removed, card disappears
|
|
|
|
2. **Migration-done page cleanup:**
|
|
- Start a new migration
|
|
- After completion, "Korábbi adatok törlése" button should appear
|
|
- Click → confirm → old data deleted
|
|
|
|
3. **FileBrowser sync:**
|
|
- After migration, check `docker logs felhom-controller | grep FileBrowser`
|
|
- Verify FileBrowser compose was regenerated
|
|
|
|
4. **Title fix:**
|
|
- Visit a non-deployed app → title shows "Telepítés"
|
|
- Visit a deployed app → title shows "Beállítások"
|
|
|
|
5. **Safety:**
|
|
- Try to delete active HDD path via API → should be rejected (403)
|
|
- Try to delete unregistered path → should be rejected (400)
|
|
- Protected paths (storage root, media root) should never be deleted |