othman.suseno/atlas
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix storage management and nfs
Some checks failed
CI / test-build (push) Has been cancelled
Details
CI / test-build (pull_request) Has been cancelled
Details

Browse Source
This commit is contained in:
othman hendy suseno
2025-12-20 12:41:50 +00:00
parent 3a25138d5b
commit 45aaec9e47
5 changed files with 595 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

172
internal/httpapp/api_handlers.go
View File

@@ -351,9 +351,60 @@ func (a *App) handleGetDataset(w http.ResponseWriter, r *http.Request) {
}
func (a *App) handleUpdateDataset(w http.ResponseWriter, r *http.Request) {
name := pathParam(r, "/api/v1/datasets/")
// TODO: Implement dataset property updates
writeJSON(w, http.StatusNotImplemented, map[string]string{"error": "not implemented", "name": name})
name := pathParamFull(r, "/api/v1/datasets/")
if name == "" {
writeError(w, errors.ErrBadRequest("dataset name required"))
return
}
var req struct {
Quota string `json:"quota"` // e.g., "10G", "1T", or "none" to remove
Compression string `json:"compression"` // e.g., "lz4", "gzip", "off"
Options map[string]string `json:"options"` // other ZFS properties
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeError(w, errors.ErrBadRequest("invalid request body"))
return
}
// Validate dataset exists
datasets, err := a.zfs.ListDatasets("")
if err != nil {
writeError(w, errors.ErrInternal("failed to validate dataset").WithDetails(err.Error()))
return
}
datasetExists := false
for _, ds := range datasets {
if ds.Name == name {
datasetExists = true
break
}
}
if !datasetExists {
writeError(w, errors.ErrNotFound(fmt.Sprintf("dataset '%s' not found", name)))
return
}
// Update dataset properties
if err := a.zfs.UpdateDataset(name, req.Quota, req.Compression, req.Options); err != nil {
log.Printf("update dataset error: %v", err)
writeError(w, errors.ErrInternal("failed to update dataset").WithDetails(err.Error()))
return
}
// Get updated dataset info
datasets, _ = a.zfs.ListDatasets("")
for _, ds := range datasets {
if ds.Name == name {
writeJSON(w, http.StatusOK, ds)
return
}
}
writeJSON(w, http.StatusOK, map[string]string{"message": "dataset updated", "name": name})
}
func (a *App) handleDeleteDataset(w http.ResponseWriter, r *http.Request) {
@@ -838,14 +889,16 @@ func (a *App) handleCreateNFSExport(w http.ResponseWriter, r *http.Request) {
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid request body"})
writeError(w, errors.ErrValidation("invalid request body"))
return
}
// Validate dataset name
if err := validation.ValidateZFSName(req.Dataset); err != nil {
writeError(w, errors.ErrValidation(err.Error()))
return
// Validate clients first
for i, client := range req.Clients {
if err := validation.ValidateCIDR(client); err != nil {
writeError(w, errors.ErrValidation(fmt.Sprintf("client[%d]: %s", i, err.Error())))
return
}
}
// Validate and sanitize path if provided
@@ -857,51 +910,73 @@ func (a *App) handleCreateNFSExport(w http.ResponseWriter, r *http.Request) {
}
}
// Validate clients
for i, client := range req.Clients {
if err := validation.ValidateCIDR(client); err != nil {
writeError(w, errors.ErrValidation(fmt.Sprintf("client[%d]: %s", i, err.Error())))
// Get all datasets to validate and find dataset
datasets, err := a.zfs.ListDatasets("")
if err != nil {
log.Printf("list datasets error: %v", err)
writeError(w, errors.ErrInternal("failed to validate dataset").WithDetails(err.Error()))
return
}
// Check if req.Dataset is a filesystem path (starts with /) or a dataset name
var datasetName string
var datasetMountpoint string
datasetExists := false
if strings.HasPrefix(req.Dataset, "/") {
// Input is a filesystem path (mountpoint), find dataset by mountpoint
for _, ds := range datasets {
if ds.Mountpoint == req.Dataset {
datasetExists = true
datasetName = ds.Name
datasetMountpoint = ds.Mountpoint
break
}
}
if !datasetExists {
writeError(w, errors.ErrNotFound(fmt.Sprintf("dataset with mountpoint '%s' not found", req.Dataset)))
return
}
} else {
// Input is a dataset name, validate it first
if err := validation.ValidateZFSName(req.Dataset); err != nil {
writeError(w, errors.ErrValidation(err.Error()))
return
}
// Find dataset by name
for _, ds := range datasets {
if ds.Name == req.Dataset {
datasetExists = true
datasetName = ds.Name
datasetMountpoint = ds.Mountpoint
break
}
}
if !datasetExists {
writeError(w, errors.ErrNotFound(fmt.Sprintf("dataset '%s' not found", req.Dataset)))
return
}
}
// Validate dataset exists
datasets, err := a.zfs.ListDatasets("")
if err != nil {
log.Printf("list datasets error: %v", err)
writeJSON(w, http.StatusInternalServerError, map[string]string{"error": "failed to validate dataset"})
return
}
datasetExists := false
for _, ds := range datasets {
if ds.Name == req.Dataset {
datasetExists = true
if req.Path == "" {
req.Path = ds.Mountpoint
}
break
}
}
if !datasetExists {
writeJSON(w, http.StatusBadRequest, map[string]string{"error": "dataset not found"})
return
// Set the correct dataset name and path
req.Dataset = datasetName
if req.Path == "" {
req.Path = datasetMountpoint
}
// Default clients to "*" (all) if not specified
if req.Clients == nil || len(req.Clients) == 0 {
if len(req.Clients) == 0 {
req.Clients = []string{"*"}
}
export, err := a.nfsStore.Create(req.Path, req.Dataset, req.Clients, req.ReadOnly, req.RootSquash)
if err != nil {
if err == storage.ErrNFSExportExists {
writeJSON(w, http.StatusConflict, map[string]string{"error": "export for this path already exists"})
writeError(w, errors.ErrConflict(fmt.Sprintf("export for path '%s' already exists", req.Path)))
return
}
log.Printf("create NFS export error: %v", err)
writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
writeError(w, errors.ErrInternal("failed to create NFS export").WithDetails(err.Error()))
return
}
@@ -909,6 +984,20 @@ func (a *App) handleCreateNFSExport(w http.ResponseWriter, r *http.Request) {
exports := a.nfsStore.List()
if err := a.nfsService.ApplyConfiguration(exports); err != nil {
log.Printf("apply NFS configuration error: %v", err)
// Export was created in store but failed to apply to system
// Try to remove from store to maintain consistency
if delErr := a.nfsStore.Delete(export.ID); delErr != nil {
log.Printf("warning: failed to rollback export creation after ApplyConfiguration failure: %v", delErr)
}
writeError(w, errors.ErrInternal("failed to apply NFS configuration").WithDetails(fmt.Sprintf("Export was created but failed to apply to NFS service: %v", err)))
return
}
// Double-check export exists
if _, getErr := a.nfsStore.Get(export.ID); getErr != nil {
log.Printf("warning: export %s was created but not found in store: %v", export.ID, getErr)
writeError(w, errors.ErrInternal("failed to verify export creation").WithDetails("Export may not have been created properly"))
return
}
writeJSON(w, http.StatusCreated, export)
@@ -977,17 +1066,17 @@ func (a *App) handleUpdateNFSExport(w http.ResponseWriter, r *http.Request) {
func (a *App) handleDeleteNFSExport(w http.ResponseWriter, r *http.Request) {
id := pathParam(r, "/api/v1/exports/nfs/")
if id == "" {
writeJSON(w, http.StatusBadRequest, map[string]string{"error": "export id required"})
writeError(w, errors.ErrValidation("export id required"))
return
}
if err := a.nfsStore.Delete(id); err != nil {
if err == storage.ErrNFSExportNotFound {
writeJSON(w, http.StatusNotFound, map[string]string{"error": err.Error()})
writeError(w, errors.ErrNotFound(fmt.Sprintf("NFS export '%s' not found", id)))
return
}
log.Printf("delete NFS export error: %v", err)
writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
writeError(w, errors.ErrInternal("failed to delete NFS export").WithDetails(err.Error()))
return
}
@@ -995,6 +1084,9 @@ func (a *App) handleDeleteNFSExport(w http.ResponseWriter, r *http.Request) {
exports := a.nfsStore.List()
if err := a.nfsService.ApplyConfiguration(exports); err != nil {
log.Printf("apply NFS configuration error: %v", err)
// Export was deleted from store but failed to apply to system
// Log warning but don't fail the request since deletion succeeded
log.Printf("warning: NFS export '%s' was deleted from store but failed to apply configuration: %v", id, err)
}
writeJSON(w, http.StatusOK, map[string]string{"message": "export deleted", "id": id})

216
internal/services/nfs.go
View File

@@ -1,7 +1,9 @@
package services
import (
"bytes"
"fmt"
"io"
"os"
"os/exec"
"strings"
@@ -24,34 +26,83 @@ func NewNFSService() *NFSService {
}
// ApplyConfiguration generates and applies NFS exports configuration
// Uses ZFS sharenfs property when possible (safer and native), falls back to /etc/exports
func (s *NFSService) ApplyConfiguration(exports []models.NFSExport) error {
s.mu.Lock()
defer s.mu.Unlock()
// Try using ZFS sharenfs property first (safer, native ZFS method)
zfsErr := s.applyZFSShareNFS(exports)
if zfsErr == nil {
return nil // Success using ZFS sharenfs
}
// If ZFS method failed, check if it's just a reload error
// If sharenfs was set but reload failed, that's acceptable - exports will work
if strings.Contains(zfsErr.Error(), "sharenfs set but reload failed") {
// ShareNFS was set successfully, just reload failed
// This is acceptable - exports are configured, just need manual reload
// Return nil to indicate success (exports are configured)
return nil
}
// Log the error for debugging but continue with fallback
// Note: We don't return error here to allow fallback to /etc/exports method
// This is intentional - if ZFS method fails completely, we try traditional method
// Fallback to /etc/exports method
config, err := s.generateExports(exports)
if err != nil {
return fmt.Errorf("generate exports: %w", err)
}
// Write configuration to a temporary file first
tmpPath := s.exportsPath + ".atlas.tmp"
if err := os.WriteFile(tmpPath, []byte(config), 0644); err != nil {
return fmt.Errorf("write exports: %w", err)
}
// Write configuration directly to /etc/exports.atlas.tmp using sudo tee
// This avoids cross-device issues and permission problems
finalTmpPath := s.exportsPath + ".atlas.tmp"
// Backup existing exports
backupPath := s.exportsPath + ".backup"
if _, err := os.Stat(s.exportsPath); err == nil {
if err := exec.Command("cp", s.exportsPath, backupPath).Run(); err != nil {
// Non-fatal, log but continue
// Use sudo tee to write directly to /etc (requires root permissions)
teeCmd := exec.Command("sudo", "-n", "tee", finalTmpPath)
teeCmd.Stdin = strings.NewReader(config)
var teeStderr bytes.Buffer
teeCmd.Stderr = &teeStderr
if err := teeCmd.Run(); err != nil {
// If sudo fails, try direct write (might work if running as root)
if err := os.WriteFile(finalTmpPath, []byte(config), 0644); err != nil {
return fmt.Errorf("write exports temp file: %w (sudo failed: %v, stderr: %s)", err, err, teeStderr.String())
}
}
// Atomically replace exports file
if err := os.Rename(tmpPath, s.exportsPath); err != nil {
return fmt.Errorf("replace exports: %w", err)
// Set proper permissions on temp file
chmodCmd := exec.Command("sudo", "-n", "chmod", "644", finalTmpPath)
_ = chmodCmd.Run() // Ignore errors, might already have correct permissions
// Backup existing exports using sudo
backupPath := s.exportsPath + ".backup"
if _, err := os.Stat(s.exportsPath); err == nil {
cpCmd := exec.Command("sudo", "-n", "cp", s.exportsPath, backupPath)
if err := cpCmd.Run(); err != nil {
// Non-fatal, log but continue
// Try direct copy as fallback
exec.Command("cp", s.exportsPath, backupPath).Run()
}
}
// Atomically replace exports file using sudo
// Use cp + rm instead of mv for better cross-device compatibility
cpCmd := exec.Command("sudo", "-n", "cp", finalTmpPath, s.exportsPath)
cpStderr := bytes.Buffer{}
cpCmd.Stderr = &cpStderr
if err := cpCmd.Run(); err != nil {
// If sudo fails, try direct copy using helper function (might work if running as root)
if err := copyFile(finalTmpPath, s.exportsPath); err != nil {
return fmt.Errorf("replace exports: %w (sudo failed: %v, stderr: %s)", err, err, cpStderr.String())
}
}
// Remove temp file after successful copy
rmCmd := exec.Command("sudo", "-n", "rm", "-f", finalTmpPath)
_ = rmCmd.Run() // Ignore errors, file might not exist
// Reload NFS exports with error recovery
reloadErr := s.reloadExports()
if reloadErr != nil {
@@ -110,10 +161,19 @@ func (s *NFSService) generateExports(exports []models.NFSExport) (string, error)
// reloadExports reloads NFS exports
func (s *NFSService) reloadExports() error {
// Use exportfs -ra to reload all exports
cmd := exec.Command("exportfs", "-ra")
// Use exportfs -ra to reload all exports (requires root)
// Try with sudo first
cmd := exec.Command("sudo", "-n", "exportfs", "-ra")
var stderr bytes.Buffer
cmd.Stderr = &stderr
if err := cmd.Run(); err != nil {
return fmt.Errorf("exportfs failed: %w", err)
// If sudo fails, try direct execution (might work if running as root)
directCmd := exec.Command("exportfs", "-ra")
directStderr := bytes.Buffer{}
directCmd.Stderr = &directStderr
if directErr := directCmd.Run(); directErr != nil {
return fmt.Errorf("exportfs failed: sudo error: %v (stderr: %s), direct error: %v (stderr: %s)", err, stderr.String(), directErr, directStderr.String())
}
}
return nil
@@ -146,3 +206,127 @@ func (s *NFSService) GetStatus() (bool, error) {
return false, nil
}
// copyFile copies a file from src to dst (helper for cross-device operations)
func copyFile(src, dst string) error {
sourceFile, err := os.Open(src)
if err != nil {
return fmt.Errorf("open source: %w", err)
}
defer sourceFile.Close()
destFile, err := os.Create(dst)
if err != nil {
return fmt.Errorf("create destination: %w", err)
}
defer destFile.Close()
if _, err := io.Copy(destFile, sourceFile); err != nil {
return fmt.Errorf("copy content: %w", err)
}
return destFile.Sync()
}
// applyZFSShareNFS applies NFS exports using ZFS sharenfs property (native, safer method)
func (s *NFSService) applyZFSShareNFS(exports []models.NFSExport) error {
// Find zfs command path
zfsPath := "zfs"
if path, err := exec.LookPath("zfs"); err == nil {
zfsPath = path
}
for _, export := range exports {
if !export.Enabled {
// Disable sharenfs for disabled exports
cmd := exec.Command("sudo", "-n", zfsPath, "set", "sharenfs=off", export.Dataset)
if err := cmd.Run(); err != nil {
// Log but continue - might not have permission or dataset doesn't exist
continue
}
continue
}
// Build sharenfs value
// Format for sharenfs:
// - "on" = share to all with default options
// - "rw" = share to all with rw
// - "rw=client1,ro=client2,options" = client-specific with options
var sharenfsValue strings.Builder
// Check if we have specific clients (not just *)
hasSpecificClients := false
for _, client := range export.Clients {
if client != "*" && client != "" {
hasSpecificClients = true
break
}
}
if !hasSpecificClients {
// No specific clients, share to all (*)
// Format must be: "rw=*" or "ro=*" with options
// Note: "rw,root_squash" is NOT valid - must use "rw=*,root_squash"
if export.ReadOnly {
sharenfsValue.WriteString("ro=*")
} else {
sharenfsValue.WriteString("rw=*")
}
// Add options after permission
if export.RootSquash {
sharenfsValue.WriteString(",root_squash")
} else {
sharenfsValue.WriteString(",no_root_squash")
}
} else {
// Has specific clients, use client-specific format
clientSpecs := []string{}
for _, client := range export.Clients {
if client == "*" || client == "" {
// Handle * as default
if export.ReadOnly {
clientSpecs = append(clientSpecs, "ro")
} else {
clientSpecs = append(clientSpecs, "rw")
}
} else {
perm := "rw"
if export.ReadOnly {
perm = "ro"
}
clientSpecs = append(clientSpecs, fmt.Sprintf("%s=%s", perm, client))
}
}
// Add options
if export.RootSquash {
clientSpecs = append(clientSpecs, "root_squash")
} else {
clientSpecs = append(clientSpecs, "no_root_squash")
}
sharenfsValue.WriteString(strings.Join(clientSpecs, ","))
}
// Set sharenfs property using sudo (atlas user has permission via sudoers)
cmd := exec.Command("sudo", "-n", zfsPath, "set", fmt.Sprintf("sharenfs=%s", sharenfsValue.String()), export.Dataset)
var stderr bytes.Buffer
cmd.Stderr = &stderr
if err := cmd.Run(); err != nil {
// If setting sharenfs fails, this method won't work - return error to trigger fallback
return fmt.Errorf("failed to set sharenfs on %s: %v (stderr: %s)", export.Dataset, err, stderr.String())
}
}
// After setting sharenfs properties, reload NFS exports
// ZFS sharenfs requires exportfs -ra to make exports visible
if err := s.reloadExports(); err != nil {
// Log error but don't fail - sharenfs is set, just needs manual reload
// Return error so caller knows reload failed, but sharenfs is already set
// This is acceptable - exports will work after manual reload
return fmt.Errorf("sharenfs set but reload failed (exports may need manual reload): %w", err)
}
return nil
}

35
internal/zfs/service.go
View File

@@ -958,6 +958,41 @@ func (s *Service) DestroyDataset(name string, recursive bool) error {
return nil
}
// UpdateDataset updates ZFS dataset properties
func (s *Service) UpdateDataset(name string, quota string, compression string, options map[string]string) error {
// Update quota if provided
if quota != "" {
quotaValue := quota
if quota == "none" || quota == "0" {
quotaValue = "none"
}
args := []string{"set", fmt.Sprintf("quota=%s", quotaValue), name}
if _, err := s.execCommand(s.zfsPath, args...); err != nil {
return translateZFSError(err, "mengupdate quota dataset", name)
}
}
// Update compression if provided
if compression != "" {
args := []string{"set", fmt.Sprintf("compression=%s", compression), name}
if _, err := s.execCommand(s.zfsPath, args...); err != nil {
return translateZFSError(err, "mengupdate compression dataset", name)
}
}
// Update other options if provided
if options != nil {
for key, value := range options {
args := []string{"set", fmt.Sprintf("%s=%s", key, value), name}
if _, err := s.execCommand(s.zfsPath, args...); err != nil {
return translateZFSError(err, fmt.Sprintf("mengupdate property %s dataset", key), name)
}
}
}
return nil
}
// ListZVOLs returns all ZVOLs
func (s *Service) ListZVOLs(pool string) ([]models.ZVOL, error) {
args := []string{"list", "-H", "-o", "name,volsize,used", "-t", "volume"}

40
web/templates/shares.html
View File

@@ -246,6 +246,8 @@ async function loadNFSExports() {
<div class="text-sm text-slate-400 space-y-1">
<p>Dataset: ${exp.dataset || 'N/A'}</p>
<p>Clients: ${exp.clients && exp.clients.length > 0 ? exp.clients.join(', ') : '*'}</p>
<p>Root Squash: ${exp.root_squash ? '<span class="text-yellow-400">Enabled</span>' : '<span class="text-green-400">Disabled</span>'}</p>
${exp.read_only ? '<p>Read-only: <span class="text-yellow-400">Yes</span></p>' : ''}
</div>
</div>
<div class="flex gap-2">
@@ -329,8 +331,23 @@ async function createNFSExport(e) {
loadNFSExports();
alert('NFS export created successfully');
} else {
const err = await res.json();
alert(`Error: ${err.error || 'Failed to create NFS export'}`);
const data = await res.json();
let errMsg = 'Failed to create NFS export';
if (data) {
if (data.message) {
errMsg = data.message;
if (data.details) {
errMsg += ': ' + data.details;
}
} else if (data.error) {
errMsg = data.error;
if (data.details) {
errMsg += ': ' + data.details;
}
}
}
alert(`Error: ${errMsg}\n\nNote: The export list has been refreshed. Please check if the export was created.`);
loadNFSExports(); // Refresh list to show current state
}
} catch (err) {
alert(`Error: ${err.message}`);
@@ -371,8 +388,23 @@ async function deleteNFSExport(id) {
loadNFSExports();
alert('NFS export deleted successfully');
} else {
const err = await res.json();
alert(`Error: ${err.error || 'Failed to delete NFS export'}`);
const data = await res.json();
let errMsg = 'Failed to delete NFS export';
if (data) {
if (data.message) {
errMsg = data.message;
if (data.details) {
errMsg += ': ' + data.details;
}
} else if (data.error) {
errMsg = data.error;
if (data.details) {
errMsg += ': ' + data.details;
}
}
}
alert(`Error: ${errMsg}`);
loadNFSExports(); // Refresh list to show current state
}
} catch (err) {
alert(`Error: ${err.message}`);

209
web/templates/storage.html
View File

@@ -233,6 +233,45 @@
</div>
</div>
<!-- Edit Dataset Modal -->
<div id="edit-dataset-modal" class="hidden fixed inset-0 bg-black/50 flex items-center justify-center z-50 p-4">
<div class="bg-slate-800 rounded-lg border border-slate-700 p-4 sm:p-6 max-w-md w-full max-h-[90vh] overflow-y-auto">
<h3 class="text-xl font-semibold text-white mb-4">Edit Dataset</h3>
<form id="edit-dataset-form" onsubmit="updateDataset(event)" class="space-y-4">
<input type="hidden" id="edit-dataset-name" name="name">
<div>
<label class="block text-sm font-medium text-slate-300 mb-1">Dataset Name</label>
<input type="text" id="edit-dataset-name-display" readonly class="w-full px-3 py-2 bg-slate-900 border border-slate-700 rounded text-white text-sm opacity-75 cursor-not-allowed">
</div>
<div>
<label class="block text-sm font-medium text-slate-300 mb-1">Quota (optional)</label>
<input type="text" id="edit-dataset-quota" name="quota" placeholder="10G, 1T, or 'none' to remove" class="w-full px-3 py-2 bg-slate-900 border border-slate-700 rounded text-white text-sm focus:outline-none focus:ring-2 focus:ring-blue-600">
<p class="text-xs text-slate-400 mt-1">Leave empty to keep current quota. Use 'none' to remove quota.</p>
</div>
<div>
<label class="block text-sm font-medium text-slate-300 mb-1">Compression (optional)</label>
<select id="edit-dataset-compression" name="compression" class="w-full px-3 py-2 bg-slate-900 border border-slate-700 rounded text-white text-sm focus:outline-none focus:ring-2 focus:ring-blue-600">
<option value="">Keep current</option>
<option value="off">off</option>
<option value="lz4">lz4</option>
<option value="zstd">zstd</option>
<option value="gzip">gzip</option>
<option value="gzip-1">gzip-1</option>
<option value="gzip-9">gzip-9</option>
</select>
</div>
<div class="flex gap-2 justify-end">
<button type="button" onclick="closeModal('edit-dataset-modal')" class="px-4 py-2 bg-slate-700 hover:bg-slate-600 text-white rounded text-sm">
Cancel
</button>
<button type="submit" class="px-4 py-2 bg-blue-600 hover:bg-blue-700 text-white rounded text-sm">
Update
</button>
</div>
</form>
</div>
</div>
<!-- Create Storage Volume Modal -->
<div id="create-zvol-modal" class="hidden fixed inset-0 bg-black/50 flex items-center justify-center z-50 p-4">
<div class="bg-slate-800 rounded-lg border border-slate-700 p-4 sm:p-6 max-w-md w-full max-h-[90vh] overflow-y-auto">
@@ -316,16 +355,38 @@ function getAuthHeaders() {
async function loadPools() {
try {
// Add cache-busting to ensure fresh data
const res = await fetch('/api/v1/pools?_=' + Date.now(), {
headers: {
...getAuthHeaders(),
'Cache-Control': 'no-cache',
'Pragma': 'no-cache'
}
});
const data = await res.json().catch(() => null);
const listEl = document.getElementById('pools-list');
if (!listEl) {
console.error('pools-list element not found');
return;
}
// Add cache-busting to ensure fresh data
const authHeaders = getAuthHeaders();
const headers = {
'Cache-Control': 'no-cache',
'Pragma': 'no-cache'
};
// Merge auth headers
Object.assign(headers, authHeaders);
const res = await fetch('/api/v1/pools?_=' + Date.now(), {
headers: headers
});
console.log('API response status:', res.status, res.statusText);
let data = null;
try {
const text = await res.text();
console.log('API response text:', text.substring(0, 200));
data = JSON.parse(text);
console.log('Parsed data:', data);
} catch (jsonErr) {
console.error('JSON parse error:', jsonErr);
listEl.innerHTML = '<p class="text-red-400 text-sm">Error: Failed to parse response</p>';
return;
}
// Handle HTTP errors
if (!res.ok) {
@@ -366,12 +427,15 @@ async function loadPools() {
}
const pools = data;
console.log('Pools array:', pools, 'Length:', pools.length);
if (pools.length === 0) {
console.log('No pools found, showing empty message');
listEl.innerHTML = '<p class="text-slate-400 text-sm">No pools found. Create a pool to get started.</p>';
return;
}
console.log('Rendering pools list...');
listEl.innerHTML = pools.map(pool => `
<div class="border-b border-slate-700 last:border-0 py-4">
<div class="flex items-center justify-between">
@@ -413,8 +477,13 @@ async function loadPools() {
</div>
</div>
`).join('');
console.log('Pools list rendered successfully');
} catch (err) {
document.getElementById('pools-list').innerHTML = `<p class="text-red-400 text-sm">Error: ${err.message}</p>`;
console.error('Error in loadPools:', err);
const listEl = document.getElementById('pools-list');
if (listEl) {
listEl.innerHTML = `<p class="text-red-400 text-sm">Error: ${err.message || 'Failed to load pools'}</p>`;
}
}
}
@@ -445,10 +514,18 @@ async function loadDatasets() {
<div class="flex-1">
<h3 class="text-lg font-semibold text-white mb-1">${ds.name}</h3>
${ds.mountpoint ? `<p class="text-sm text-slate-400">${ds.mountpoint}</p>` : ''}
<div class="text-xs text-slate-500 mt-1">
Used: ${formatBytes(ds.used || 0)} | Available: ${formatBytes(ds.available || 0)}
</div>
</div>
<div class="flex gap-2">
<button onclick="showEditDatasetModal('${ds.name}')" class="px-3 py-1.5 bg-blue-600 hover:bg-blue-700 text-white rounded text-sm">
Edit
</button>
<button onclick="deleteDataset('${ds.name}')" class="px-3 py-1.5 bg-red-600 hover:bg-red-700 text-white rounded text-sm">
Delete
</button>
</div>
<button onclick="deleteDataset('${ds.name}')" class="px-3 py-1.5 bg-red-600 hover:bg-red-700 text-white rounded text-sm">
Delete
</button>
</div>
</div>
`).join('');
@@ -695,6 +772,32 @@ function showCreateDatasetModal() {
document.getElementById('create-dataset-modal').classList.remove('hidden');
}
async function showEditDatasetModal(datasetName) {
// Load dataset details first
try {
const res = await fetch(`/api/v1/datasets/${encodeURIComponent(datasetName)}`, { headers: getAuthHeaders() });
if (!res.ok) {
alert('Failed to load dataset details');
return;
}
const dataset = await res.json();
// Populate form
document.getElementById('edit-dataset-name').value = dataset.name;
document.getElementById('edit-dataset-name-display').value = dataset.name;
// Get current quota and compression from dataset properties
// Note: These might not be in the response, so we'll leave them empty
document.getElementById('edit-dataset-quota').value = '';
document.getElementById('edit-dataset-compression').value = '';
// Show modal
document.getElementById('edit-dataset-modal').classList.remove('hidden');
} catch (err) {
alert(`Error: ${err.message}`);
}
}
function showCreateZVOLModal() {
document.getElementById('create-zvol-modal').classList.remove('hidden');
}
@@ -831,8 +934,64 @@ async function createDataset(e) {
loadDatasets();
alert('Dataset created successfully');
} else {
const err = await res.json();
alert(`Error: ${err.error || 'Failed to create dataset'}`);
const data = await res.json();
let errMsg = 'Failed to create dataset';
if (data) {
if (data.message) {
errMsg = data.message;
if (data.details) {
errMsg += ': ' + data.details;
}
} else if (data.error) {
errMsg = data.error;
}
}
alert(`Error: ${errMsg}`);
}
} catch (err) {
alert(`Error: ${err.message}`);
}
}
async function updateDataset(e) {
e.preventDefault();
const formData = new FormData(e.target);
const datasetName = formData.get('name');
const data = {};
if (formData.get('quota')) {
data.quota = formData.get('quota');
}
if (formData.get('compression')) {
data.compression = formData.get('compression');
}
try {
const res = await fetch(`/api/v1/datasets/${encodeURIComponent(datasetName)}`, {
method: 'PUT',
headers: getAuthHeaders(),
body: JSON.stringify(data)
});
if (res.ok) {
closeModal('edit-dataset-modal');
e.target.reset();
loadDatasets();
alert('Dataset updated successfully');
} else {
const data = await res.json();
let errMsg = 'Failed to update dataset';
if (data) {
if (data.message) {
errMsg = data.message;
if (data.details) {
errMsg += ': ' + data.details;
}
} else if (data.error) {
errMsg = data.error;
}
}
alert(`Error: ${errMsg}`);
}
} catch (err) {
alert(`Error: ${err.message}`);
@@ -993,8 +1152,24 @@ async function exportPool(name) {
}
}
// Load initial data
loadPools();
// Load initial data when DOM is ready
(function() {
function initLoad() {
console.log('Initializing loadPools...');
try {
loadPools();
} catch (err) {
console.error('Error calling loadPools:', err);
}
}
if (document.readyState === 'loading') {
document.addEventListener('DOMContentLoaded', initLoad);
} else {
// DOM is already ready
setTimeout(initLoad, 100); // Small delay to ensure DOM is fully ready
}
})();
</script>
{{end}}