-
-
-
- Please enter the password for
{{.Server}} to shutdown the server.
+
+
+
+
+
+ To use the shutdown feature, add SHUTDOWN_PASSWORD to your .env
+ file.
+
+
+
+
{{end}}
-
+
+
+
diff --git a/utils.go b/utils.go
index 28e111b..c39d4dd 100644
--- a/utils.go
+++ b/utils.go
@@ -2,6 +2,7 @@ package main
import (
"bytes"
+ "encoding/json"
"fmt"
"html/template"
"log"
@@ -9,8 +10,20 @@ import (
"os/exec"
"path/filepath"
"runtime"
+ "time"
)
+// ScheduleConfig holds the backup window schedule settings
+type ScheduleConfig struct {
+ Enabled bool `json:"enabled"`
+ StartTime string `json:"startTime"` // Format: "HH:MM" (24-hour)
+ EndTime string `json:"endTime"` // Format: "HH:MM" (24-hour)
+ Frequency string `json:"frequency"` // "daily", "every2days", "weekly", "monthly"
+ LastRun string `json:"lastRun"` // ISO8601 format - when the schedule last ran
+ AutoShutdown bool `json:"autoShutdown"` // Whether to automatically shut down at end time
+ StartedBySchedule bool `json:"startedBySchedule"` // Whether server was started by scheduler
+}
+
// StatusData holds data for the HTML template
type StatusData struct {
Server string
@@ -20,9 +33,15 @@ type StatusData struct {
ConfirmShutdown bool
AskPassword bool
ErrorMessage string
+ Schedule ScheduleConfig
+ LastUpdated string
+ RefreshInterval int
}
var tmpl *template.Template
+var scheduleConfig ScheduleConfig
+var scheduleConfigPath = "schedule.json"
+var shutdownPassword string // Will be loaded from environment
// Setup the HTML template
func setupTemplate() error {
@@ -49,12 +68,362 @@ func setupTemplate() error {
return fmt.Errorf("failed to parse template: %v", err)
}
+ // Load schedule config
+ err = loadScheduleConfig()
+ if err != nil {
+ log.Printf("Warning: Failed to load schedule config: %v", err)
+ // Continue with default (empty) schedule config
+ }
+
+ // Check for required system tools
+ checkRequiredTools()
+
+ // Load shutdown password from environment
+ shutdownPassword = os.Getenv("SHUTDOWN_PASSWORD")
+ if shutdownPassword == "" {
+ log.Println("SHUTDOWN_PASSWORD not set in environment. Automatic shutdown will be disabled.")
+ } else {
+ log.Println("SHUTDOWN_PASSWORD loaded from environment")
+ }
+
return nil
}
+// Check if required system tools are available
+func checkRequiredTools() {
+ // Check for wakeonlan command
+ if _, err := exec.LookPath("wakeonlan"); err != nil {
+ if _, err := exec.LookPath("etherwake"); err != nil {
+ if _, err := exec.LookPath("wol"); err != nil {
+ log.Printf("WARNING: No Wake-on-LAN tools found. Please install wakeonlan, etherwake, or wol package.")
+ log.Printf("Installation instructions:")
+ log.Printf(" - For Debian/Ubuntu: sudo apt-get install wakeonlan")
+ log.Printf(" - For macOS: brew install wakeonlan")
+ log.Printf(" - For Windows: Download from https://www.depicus.com/wake-on-lan/wake-on-lan-cmd")
+ } else {
+ log.Printf("Using 'wol' for Wake-on-LAN functionality")
+ }
+ } else {
+ log.Printf("Using 'etherwake' for Wake-on-LAN functionality")
+ }
+ } else {
+ log.Printf("Found 'wakeonlan' command for Wake-on-LAN functionality")
+ }
+
+ // Check for ping command (needed for server status checks)
+ if _, err := exec.LookPath("ping"); err != nil {
+ log.Printf("WARNING: 'ping' command not found. Server status checks may fail.")
+ }
+}
+
+// Load schedule configuration from file
+func loadScheduleConfig() error {
+ // Check if config file exists
+ if _, err := os.Stat(scheduleConfigPath); os.IsNotExist(err) {
+ // Create default config
+ scheduleConfig = ScheduleConfig{
+ Enabled: false,
+ StartTime: "",
+ EndTime: "",
+ Frequency: "daily",
+ LastRun: "",
+ AutoShutdown: false,
+ StartedBySchedule: false,
+ }
+ // Save default config
+ return saveScheduleConfig()
+ }
+
+ // Read the file
+ data, err := os.ReadFile(scheduleConfigPath)
+ if err != nil {
+ return fmt.Errorf("failed to read schedule config file: %v", err)
+ }
+
+ // Unmarshal JSON data
+ err = json.Unmarshal(data, &scheduleConfig)
+ if err != nil {
+ return fmt.Errorf("failed to parse schedule config: %v", err)
+ }
+
+ // Log loaded configuration for debugging
+ log.Printf("Loaded schedule config: Enabled=%v, StartTime=%s, EndTime=%s, Frequency=%s",
+ scheduleConfig.Enabled, scheduleConfig.StartTime, scheduleConfig.EndTime, scheduleConfig.Frequency)
+
+ return nil
+}
+
+// Save schedule configuration to file
+func saveScheduleConfig() error {
+ data, err := json.MarshalIndent(scheduleConfig, "", " ")
+ if err != nil {
+ return fmt.Errorf("failed to marshal schedule config: %v", err)
+ }
+
+ err = os.WriteFile(scheduleConfigPath, data, 0644)
+ if err != nil {
+ return fmt.Errorf("failed to save schedule config: %v", err)
+ }
+
+ return nil
+}
+
+// GetScheduleConfig returns the current schedule config
+func GetScheduleConfig() ScheduleConfig {
+ return scheduleConfig
+}
+
+// UpdateScheduleConfig updates the schedule configuration
+func UpdateScheduleConfig(newConfig ScheduleConfig) error {
+ scheduleConfig = newConfig
+ return saveScheduleConfig()
+}
+
+// CheckSchedule checks if server should be on/off based on schedule
+func CheckSchedule() (shouldBeOn bool) {
+ // If schedule is not enabled, do nothing
+ if !scheduleConfig.Enabled {
+ return false
+ }
+
+ // If start time or end time is empty, the schedule is not properly configured
+ if scheduleConfig.StartTime == "" || scheduleConfig.EndTime == "" {
+ log.Printf("Schedule configuration incomplete: StartTime=%s, EndTime=%s",
+ scheduleConfig.StartTime, scheduleConfig.EndTime)
+ return false
+ }
+
+ now := time.Now()
+ today := now.Format("2006-01-02")
+
+ // Get current time as just hours and minutes for direct string comparison first
+ currentTimeStr := now.Format("15:04")
+
+ // Log the exact time comparison we're doing
+ log.Printf("Schedule debug: Current=%s, Start=%s, End=%s, LastRun=%s",
+ currentTimeStr, scheduleConfig.StartTime, scheduleConfig.EndTime, scheduleConfig.LastRun)
+
+ // Parse start time with proper error handling
+ startTime, err := time.Parse("2006-01-02 15:04", fmt.Sprintf("%s %s", today, scheduleConfig.StartTime))
+ if err != nil {
+ log.Printf("Error parsing start time '%s': %v", scheduleConfig.StartTime, err)
+ return false
+ }
+
+ // Parse end time with proper error handling
+ endTime, err := time.Parse("2006-01-02 15:04", fmt.Sprintf("%s %s", today, scheduleConfig.EndTime))
+ if err != nil {
+ log.Printf("Error parsing end time '%s': %v", scheduleConfig.EndTime, err)
+ return false
+ }
+
+ // If end time is before start time, it means the window spans to the next day
+ if endTime.Before(startTime) {
+ endTime = endTime.AddDate(0, 0, 1)
+
+ // Special case: if we're after midnight but before the end time
+ // we need to adjust the start time to be from yesterday
+ if now.Before(endTime) && now.After(time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())) {
+ startTime = startTime.AddDate(0, 0, -1)
+ }
+ }
+
+ // Check if the schedule should run today based on frequency
+ // Check if we're in the schedule window
+ if !ShouldRunToday(now) {
+ log.Printf("Schedule is active but not set to run today based on frequency: %s", scheduleConfig.Frequency)
+ return false
+ }
+
+ // Check for auto shutdown at end time
+ if currentTimeStr == scheduleConfig.EndTime {
+ if scheduleConfig.AutoShutdown && shutdownPassword != "" && isServerOnline() {
+ // Only shut down if the server was started by the scheduler
+ if scheduleConfig.StartedBySchedule {
+ log.Printf("Auto shutdown triggered at schedule end time %s", scheduleConfig.EndTime)
+
+ // Try up to 3 times to shut down the server
+ var shutdownSuccessful bool
+ for attempt := 1; attempt <= 3; attempt++ {
+ log.Printf("Auto shutdown attempt %d/3", attempt)
+ err := shutdownServer(shutdownPassword)
+ if err != nil {
+ log.Printf("Auto shutdown attempt %d failed: %v", attempt, err)
+ if attempt < 3 {
+ time.Sleep(3 * time.Second)
+ }
+ } else {
+ log.Printf("Auto shutdown initiated successfully on attempt %d", attempt)
+ shutdownSuccessful = true
+ break
+ }
+ }
+
+ if !shutdownSuccessful {
+ log.Printf("All auto shutdown attempts failed")
+ }
+ } else {
+ log.Printf("Server was not started by scheduler, skipping auto shutdown")
+ }
+ }
+ }
+
+ // Check if current time is within the schedule window
+ // Check if we're between start and end times
+ if currentTimeStr == scheduleConfig.StartTime {
+ log.Printf("Schedule match: Current time exactly matches start time")
+ shouldBeOn = true
+ } else if currentTimeStr == scheduleConfig.EndTime {
+ log.Printf("Schedule end: Current time exactly matches end time")
+ shouldBeOn = false
+
+ // Check if auto shutdown is enabled
+ if scheduleConfig.AutoShutdown && shutdownPassword != "" && isServerOnline() {
+ // Only shut down if the server was started by the scheduler
+ if scheduleConfig.StartedBySchedule {
+ log.Printf("Auto shutdown is enabled - attempting to shut down server at end time")
+
+ // Try up to 3 times to shut down the server
+ var shutdownSuccessful bool
+ for attempt := 1; attempt <= 3; attempt++ {
+ log.Printf("Auto shutdown attempt %d/3", attempt)
+ err := shutdownServer(shutdownPassword)
+ if err != nil {
+ log.Printf("Auto shutdown attempt %d failed: %v", attempt, err)
+ if attempt < 3 {
+ time.Sleep(3 * time.Second)
+ }
+ } else {
+ log.Printf("Auto shutdown initiated successfully on attempt %d", attempt)
+ shutdownSuccessful = true
+ break
+ }
+ }
+
+ if !shutdownSuccessful {
+ log.Printf("All auto shutdown attempts failed")
+ }
+ } else {
+ log.Printf("Server was not started by scheduler, skipping auto shutdown")
+ }
+ }
+ } else {
+ // ONLY consider the server should be on at EXACT start time or EXACT end time
+ shouldBeOn = (currentTimeStr == scheduleConfig.StartTime)
+
+ // Log that we're waiting for exact times for actions
+ if currentTimeStr != scheduleConfig.StartTime && currentTimeStr != scheduleConfig.EndTime {
+ log.Printf("Not at exact schedule times - no action needed until exact start/end time")
+ }
+ }
+
+ log.Printf("Schedule window check: Current=%v, Start=%v, End=%v, ShouldBeOn=%v",
+ now.Format("15:04:05"), startTime.Format("15:04:05"), endTime.Format("15:04:05"), shouldBeOn)
+
+ // Explicitly check end time for better debugging
+ if scheduleConfig.EndTime != "" && currentTimeStr == scheduleConfig.EndTime {
+ log.Printf("EXACT END TIME MATCH! Current time %s equals end time - schedule window should close", currentTimeStr)
+ }
+
+ // If we're at exact start time, update the LastRun timestamp
+ if currentTimeStr == scheduleConfig.StartTime && ShouldRunToday(now) {
+ // We only track that we've seen the start time
+ log.Printf("Exact start time reached - marking schedule run")
+
+ // Don't automatically boot the server here - let the main scheduler handle it
+ // We're just updating state information
+ scheduleConfig.LastRun = now.Format(time.RFC3339)
+ if err := saveScheduleConfig(); err != nil {
+ log.Printf("Warning: Failed to save schedule config: %v", err)
+ }
+ }
+
+ return shouldBeOn
+}
+
+// ShouldRunToday checks if the schedule should run today based on frequency
+func ShouldRunToday(now time.Time) bool {
+ // We no longer check for windows - we only check at exact times
+ currentTimeStr := now.Format("15:04")
+ today := now.Format("2006-01-02")
+
+ startTime, startErr := time.Parse("2006-01-02 15:04", fmt.Sprintf("%s %s", today, scheduleConfig.StartTime))
+ endTime, endErr := time.Parse("2006-01-02 15:04", fmt.Sprintf("%s %s", today, scheduleConfig.EndTime))
+
+ if startErr == nil && endErr == nil {
+ // If end time is before start time, it means the window spans to the next day
+ if endTime.Before(startTime) {
+ endTime = endTime.AddDate(0, 0, 1)
+ }
+
+ // Only log that we're at an exact schedule time
+ if currentTimeStr == scheduleConfig.StartTime {
+ log.Println("Currently at exact start time - schedule should be active")
+ return true
+ }
+ }
+
+ // If no previous run, allow it to run
+ if scheduleConfig.LastRun == "" {
+ log.Println("No previous run recorded, schedule can run today")
+ return true
+ }
+
+ lastRun, err := time.Parse(time.RFC3339, scheduleConfig.LastRun)
+ if err != nil {
+ log.Printf("Error parsing last run date '%s': %v", scheduleConfig.LastRun, err)
+ // If we can't parse the date, better to let it run than to block it
+ return true
+ }
+
+ // Don't allow running multiple times on the same day unless
+ // it's been reset explicitly (LastRun set to empty)
+ if lastRun.Year() == now.Year() && lastRun.YearDay() == now.YearDay() {
+ // Check if we've passed the end time today - if so, we can reset for next run
+ if scheduleConfig.EndTime != "" && currentTimeStr > scheduleConfig.EndTime {
+ log.Println("Current time is after end time - resetting for next run")
+ scheduleConfig.LastRun = ""
+ scheduleConfig.StartedBySchedule = false // Reset this flag too
+ saveScheduleConfig()
+ return false
+ }
+
+ log.Println("Schedule already ran today, skipping")
+ return false
+ }
+
+ switch scheduleConfig.Frequency {
+ case "daily":
+ // Run every day
+ log.Println("Daily schedule: allowed to run today")
+ return true
+ case "every2days":
+ // Check if at least 2 days have passed
+ elapsed := now.Sub(lastRun)
+ eligible := elapsed >= 48*time.Hour
+ log.Printf("Every 2 days schedule: %v hours elapsed, eligible=%v", elapsed.Hours(), eligible)
+ return eligible
+ case "weekly":
+ // Check if at least 7 days have passed
+ elapsed := now.Sub(lastRun)
+ eligible := elapsed >= 7*24*time.Hour
+ log.Printf("Weekly schedule: %v days elapsed, eligible=%v", elapsed.Hours()/24, eligible)
+ return eligible
+ case "monthly":
+ // Check if last run was in a different month
+ sameMonth := lastRun.Month() == now.Month() && lastRun.Year() == now.Year()
+ log.Printf("Monthly schedule: eligible=%v", !sameMonth)
+ return !sameMonth
+ default:
+ log.Printf("Unknown frequency '%s', defaulting to daily", scheduleConfig.Frequency)
+ return true
+ }
+}
+
// Check if server is online
func isServerOnline() bool {
var cmd *exec.Cmd
+ var stdout, stderr bytes.Buffer
// macOS and Linux have slightly different ping commands
if runtime.GOOS == "darwin" {
@@ -63,38 +432,186 @@ func isServerOnline() bool {
cmd = exec.Command("ping", "-c", "1", "-W", "1", serverName)
}
+ // Capture output for debugging
+ cmd.Stdout = &stdout
+ cmd.Stderr = &stderr
+
+ log.Printf("Checking if server %s is online...", serverName)
err := cmd.Run()
- return err == nil
+
+ if err != nil {
+ // Only log the full error in debug mode to avoid spamming the logs
+ if stderr.String() != "" {
+ log.Printf("Server %s is offline: %v - %s", serverName, err, stderr.String())
+ } else {
+ log.Printf("Server %s is offline", serverName)
+ }
+ return false
+ }
+
+ log.Printf("Server %s is online", serverName)
+ return true
}
// Send WOL packet
func sendWakeOnLAN() error {
log.Printf("Sending WOL packet to %s (%s)", serverName, macAddress)
- cmd := exec.Command("wakeonlan", macAddress)
- return cmd.Run()
+
+ // Check if wakeonlan command exists
+ if _, err := exec.LookPath("wakeonlan"); err == nil {
+ // Create the command
+ cmd := exec.Command("wakeonlan", macAddress)
+
+ // Capture both stdout and stderr
+ var stdout, stderr bytes.Buffer
+ cmd.Stdout = &stdout
+ cmd.Stderr = &stderr
+
+ // Execute the command
+ err := cmd.Run()
+
+ // Log the result
+ if err != nil {
+ log.Printf("WOL command failed: %v - stderr: %s", err, stderr.String())
+ return fmt.Errorf("WOL command failed: %v - %s", err, stderr.String())
+ }
+
+ output := stdout.String()
+ if output != "" {
+ log.Printf("WOL command output: %s", output)
+ }
+
+ log.Printf("WOL packet sent successfully to %s", macAddress)
+ return nil
+ } else {
+ // wakeonlan command not found, try etherwake
+ if _, err := exec.LookPath("etherwake"); err == nil {
+ log.Printf("Using etherwake as wakeonlan alternative")
+ cmd := exec.Command("etherwake", macAddress)
+
+ var stdout, stderr bytes.Buffer
+ cmd.Stdout = &stdout
+ cmd.Stderr = &stderr
+
+ err := cmd.Run()
+ if err != nil {
+ log.Printf("etherwake command failed: %v - stderr: %s", err, stderr.String())
+ return fmt.Errorf("etherwake command failed: %v - %s", err, stderr.String())
+ }
+
+ log.Printf("WOL packet sent successfully via etherwake to %s", macAddress)
+ return nil
+ } else {
+ // Try wol command as last resort
+ if _, err := exec.LookPath("wol"); err == nil {
+ log.Printf("Using wol as wakeonlan alternative")
+ cmd := exec.Command("wol", macAddress)
+
+ var stdout, stderr bytes.Buffer
+ cmd.Stdout = &stdout
+ cmd.Stderr = &stderr
+
+ err := cmd.Run()
+ if err != nil {
+ log.Printf("wol command failed: %v - stderr: %s", err, stderr.String())
+ return fmt.Errorf("wol command failed: %v - %s", err, stderr.String())
+ }
+
+ log.Printf("WOL packet sent successfully via wol to %s", macAddress)
+ return nil
+ } else {
+ // Implement a fallback pure Go WOL solution
+ log.Printf("No WOL tools found. Please install wakeonlan, etherwake, or wol package.")
+ log.Printf("Installation instructions:")
+ log.Printf(" - For Debian/Ubuntu: sudo apt-get install wakeonlan")
+ log.Printf(" - For macOS: brew install wakeonlan")
+ log.Printf(" - For Windows: Download from https://www.depicus.com/wake-on-lan/wake-on-lan-cmd")
+
+ return fmt.Errorf("wakeonlan command not found in PATH. Please install wakeonlan tool")
+ }
+ }
+ }
}
// Shutdown server with password
func shutdownServer(password string) error {
- log.Printf("Sending shutdown command to %s", serverName)
+ log.Printf("Sending shutdown command to %s", serverName)
- // Add more SSH options to handle potential issues
- cmd := exec.Command("sshpass", "-p", password, "ssh",
- "-o", "StrictHostKeyChecking=no",
- "-o", "UserKnownHostsFile=/dev/null",
- "-o", "LogLevel=ERROR",
- fmt.Sprintf("%s@%s", serverUser, serverName),
- "sudo", "-S", "shutdown", "-h", "now")
+ var err error
+ var stderr bytes.Buffer
- // Capture stderr to log any error messages
- var stderr bytes.Buffer
- cmd.Stderr = &stderr
+ // First try using sshpass with password
+ if _, err := exec.LookPath("sshpass"); err == nil {
+ log.Println("Using sshpass for authentication")
+ log.Printf("Password being used: %s", password)
- err := cmd.Run()
- if err != nil {
- log.Printf("SSH Error details: %s", stderr.String())
- return fmt.Errorf("SSH command failed: %v - %s", err, stderr.String())
- }
+ // Add more SSH options to handle potential issues
+ cmd := exec.Command("sshpass", "-p", password, "ssh",
+ "-o", "StrictHostKeyChecking=no",
+ "-o", "UserKnownHostsFile=/dev/null",
+ "-o", "LogLevel=ERROR",
+ "-o", "ConnectTimeout=10",
+ fmt.Sprintf("%s@%s", serverUser, serverName),
+ "sudo", "-S", "shutdown", "-h", "now")
- return nil
+ // Capture stderr to log any error messages
+ stderr.Reset()
+ cmd.Stderr = &stderr
+ cmd.Stdin = bytes.NewBufferString(password + "\n")
+
+ err = cmd.Run()
+ if err == nil {
+ log.Println("SSH command executed successfully using sshpass")
+ return nil
+ }
+
+ log.Printf("sshpass method failed: %v - %s", err, stderr.String())
+ }
+
+ // Try direct SSH with password via stdin
+ log.Println("Trying direct SSH with password via stdin")
+ log.Printf("Password being used: %s", password)
+
+ cmd := exec.Command("ssh",
+ "-o", "StrictHostKeyChecking=no",
+ "-o", "UserKnownHostsFile=/dev/null",
+ "-o", "LogLevel=ERROR",
+ "-o", "ConnectTimeout=10",
+ fmt.Sprintf("%s@%s", serverUser, serverName),
+ "sudo", "-S", "shutdown", "-h", "now")
+
+ stderr.Reset()
+ cmd.Stderr = &stderr
+ cmd.Stdin = bytes.NewBufferString(password + "\n")
+
+ err = cmd.Run()
+ if err == nil {
+ log.Println("SSH command executed successfully using direct SSH")
+ return nil
+ }
+
+ log.Printf("SSH Error details: %s", stderr.String())
+
+ // Try a simpler shutdown command as a fallback
+ log.Println("Trying simpler shutdown command as fallback")
+ log.Printf("Password being used: %s", password)
+
+ cmd = exec.Command("ssh",
+ "-o", "StrictHostKeyChecking=no",
+ "-o", "UserKnownHostsFile=/dev/null",
+ "-o", "LogLevel=ERROR",
+ fmt.Sprintf("%s@%s", serverUser, serverName),
+ "sudo", "shutdown", "now")
+
+ stderr.Reset()
+ cmd.Stderr = &stderr
+ cmd.Stdin = bytes.NewBufferString(password + "\n")
+
+ err = cmd.Run()
+ if err != nil {
+ log.Printf("All shutdown attempts failed: %v - %s", err, stderr.String())
+ return fmt.Errorf("SSH command failed: %v - %s", err, stderr.String())
+ }
+
+ return nil
}