Dashboard

// Health check endpoint handler
healthHandler := func(c *core.RequestEvent) error {
    // If not already authenticated, show login template
    if c.Auth == nil || !c.Auth.IsSuperuser() {
        // Execute login template
        var buf bytes.Buffer
        if err := tmpl.ExecuteTemplate(&buf, "login.tmpl", loginData); err != nil {
            return NewTemplateError("login_template_execution", "Failed to execute login template", err)
        }
        return c.HTML(http.StatusOK, buf.String())
    }

    // User is authenticated, show the dashboard
    data, err := s.prepareTemplateData()
    if err != nil {
        return NewHTTPError("health_check", "Failed to collect system stats", http.StatusInternalServerError, err)
    }

    var buf bytes.Buffer
    if err := tmpl.ExecuteTemplate(&buf, "index.tmpl", data); err != nil {
        return NewTemplateError("health_template_execution", "Failed to execute template", err)
    }

    return c.HTML(http.StatusOK, buf.String())
}

func (s *Server) prepareTemplateData() (interface{}, error) {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    sysStats, err := monitoring.CollectSystemStats(ctx, s.stats.StartTime)
    if err != nil {
        // Log partial errors but continue
        if errs, ok := err.(interface{ Unwrap() []error }); ok {
            for _, k := range errs.Unwrap() {
                s.App().Logger().Warn("Failed to collect system stats", "error", k)
            }
        }
    }

    // Get analytics data
    var analyticsData *analytics.Data
    if s.analytics != nil {
        analyticsData, _ = s.analytics.GetData()
    } else {
        analyticsData = analytics.DefaultData()
    }

    data := struct {
        Status           string
        UptimeDuration   string
        ServerStats      *ServerStats
        SystemStats      *monitoring.SystemStats
        AvgRequestTimeMs float64
        MemoryUsageStr   string
        DiskUsageStr     string
        LastCheckTime    time.Time
        RequestRate      float64
        AnalyticsData    *analytics.Data
        PBAdminURL       string
    }{
        Status:           "Healthy",
        UptimeDuration:   time.Since(s.stats.StartTime).Round(time.Second).String(),
        ServerStats:      s.stats,
        SystemStats:      sysStats,
        AvgRequestTimeMs: float64(s.stats.AverageRequestTime.Load()) / 1e6,
        MemoryUsageStr:   fmt.Sprintf("%.2f/%.2f GB", float64(sysStats.MemoryInfo.Used)/1024/1024/1024, float64(sysStats.MemoryInfo.Total)/1024/1024/1024),
        DiskUsageStr:     fmt.Sprintf("%.2f/%.2f GB", float64(sysStats.DiskUsed)/1024/1024/1024, float64(sysStats.DiskTotal)/1024/1024/1024),
        LastCheckTime:    time.Now(),
        RequestRate:      float64(s.stats.TotalRequests.Load()) / time.Since(s.stats.StartTime).Seconds(),
        AnalyticsData:    analyticsData,
        PBAdminURL:       "/_/",
    }

    return data, nil
}

func (s *Server) RegisterHealthRoute(e *core.ServeEvent) {
    // Automatically discover and parse all templates from embedded filesystem
    var templateFiles []string

    err := fs.WalkDir(TemplateFS, "templates", func(path string, d fs.DirEntry, err error) error {
        if err != nil {
            return err
        }

        // Only include .tmpl files
        if !d.IsDir() && filepath.Ext(path) == ".tmpl" {
            templateFiles = append(templateFiles, path)
        }

        return nil
    })

    if err != nil {
        log.Printf("Error discovering templates: %v", err)
        return
    }

    // Parse all discovered templates
    tmpl, err := template.New("").Funcs(templateFuncs).ParseFS(TemplateFS, templateFiles...)
    if err != nil {
        log.Printf("Error parsing health templates: %v", err)
        return
    }

    // Register the main health route
    e.Router.GET("/_/_", healthHandler)
}

var templateFuncs = template.FuncMap{
    "multiply": func(a, b float64) float64 {
        return a * b
    },
    "divide": func(a, b any) float64 {
        // Type conversion and division
    },
    "formatBytes": func(bytes uint64) string {
        const unit = 1024
        if bytes < unit {
            return fmt.Sprintf("%d B", bytes)
        }
        div, exp := uint64(unit), 0
        for n := bytes / unit; n >= unit; n /= unit {
            div *= unit
            exp++
        }
        return fmt.Sprintf("%.1f %cB", float64(bytes)/float64(div), "KMGTPE"[exp])
    },
    "avgCPUUsage": func(cpus []monitoring.CPUInfo) float64 {
        if len(cpus) == 0 {
            return 0
        }
        var total float64
        for _, cpu := range cpus {
            total += cpu.Usage
        }
        return total / float64(len(cpus))
    },
    "formatTime": func(t time.Time) string {
        return t.Format("15:04:05")
    },
    "getDiskTemp": func(stats *monitoring.SystemStats) float64 {
        // Extract disk temperature from sensors
    },
    "getSystemTemp": func(stats *monitoring.SystemStats) float64 {
        // Extract system temperature from sensors
    },
}

templates/
├── index.tmpl              # Main dashboard
├── login.tmpl              # Authentication page
├── error.tmpl              # Error pages
├── components/             # Reusable components
│   ├── system_health.tmpl
│   ├── analytics.tmpl
│   ├── jobs.tmpl
│   └── runtime_stats.tmpl
├── css/                    # Stylesheets
└── scripts/                # JavaScript

setInterval(async () => {
  const response = await fetch('/_/_', {
    headers: { 'Accept': 'application/json' }
  });
  const data = await response.json();
  updateDashboard(data);
}, 5000);

PBAdminURL: "/_/",

if err != nil {
    return NewHTTPError("health_check", "Failed to collect system stats", http.StatusInternalServerError, err)
}

// Custom template data
type CustomData struct {
    // Add your custom fields
    CustomMetric int
}

// Extend prepareTemplateData() to include custom data