diff --git a/handlers/instance.go b/handlers/instance.go index 29c0fb7..e364639 100644 --- a/handlers/instance.go +++ b/handlers/instance.go @@ -15,7 +15,7 @@ import ( "super-frpc/database" "super-frpc/global" "super-frpc/postLog" - "super-frpc/service" + "super-frpc/sys" "super-frpc/utils" "super-frpc/watchdog" ) @@ -98,7 +98,7 @@ func CreateInstanceHandler(w http.ResponseWriter, r *http.Request) { return } - configDir, err := service.GetConfigDir() + configDir, err := sys.GetConfigDir() if err != nil { postLog.Error(fmt.Sprintf("[CreateInstanceHandler] Failed to get config directory: %v", err)) utils.SendErrorResponse(w, http.StatusInternalServerError, "Failed to get config directory") @@ -142,16 +142,16 @@ func CreateInstanceHandler(w http.ResponseWriter, r *http.Request) { return } - if err := service.CreateBootService(createdInstance.ID); err != nil { + if err := sys.CreateBootService(createdInstance.ID); err != nil { database.DBRemoveFrpcInstanceByID(createdInstance.ID) os.Remove(configPath) - postLog.Error(fmt.Sprintf("[CreateInstanceHandler] Failed to create boot service for instance %s: %v", req.InstanceInfo.Name, err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, "Failed to create boot service") + postLog.Error(fmt.Sprintf("[CreateInstanceHandler] Failed to create boot sys for instance %s: %v", req.InstanceInfo.Name, err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, "Failed to create boot sys") return } if req.BootAtStart { - if err := service.SetBootAtStart(createdInstance.ID); err != nil { + if err := sys.SetBootAtStart(createdInstance.ID); err != nil { postLog.Error(fmt.Sprintf("[CreateInstanceHandler] Failed to set boot at start for instance %s: %v", req.InstanceInfo.Name, err)) utils.SendErrorResponse(w, http.StatusInternalServerError, "Failed to set boot at start") return @@ -213,9 +213,9 @@ func DeleteInstanceHandler(w http.ResponseWriter, r *http.Request) { return } - if err := service.RemoveBootService(instanceID); err != nil { - postLog.Error(fmt.Sprintf("[DeleteInstanceHandler] Failed to remove boot service for instance %s: %v", instance.Name, err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, "Failed to remove boot service") + if err := sys.RemoveBootService(instanceID); err != nil { + postLog.Error(fmt.Sprintf("[DeleteInstanceHandler] Failed to remove boot sys for instance %s: %v", instance.Name, err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, "Failed to remove boot sys") return } @@ -390,7 +390,7 @@ func handleSystemConfigModify(w http.ResponseWriter, r *http.Request, instance d var newConfigPath string if newName != instance.Name || newRunUser != instance.RunUser { - configDir, err := service.GetConfigDir() + configDir, err := sys.GetConfigDir() if err != nil { postLog.Error(fmt.Sprintf("[handleSystemConfigModify] Failed to get config directory: %v", err)) utils.SendErrorResponse(w, http.StatusInternalServerError, "Failed to get config directory") @@ -424,12 +424,12 @@ func handleSystemConfigModify(w http.ResponseWriter, r *http.Request, instance d } if newBootAtStart { - if err := service.RemoveBootAtStart(instance.ID); err != nil { + if err := sys.RemoveBootAtStart(instance.ID); err != nil { postLog.Error(fmt.Sprintf("[handleSystemConfigModify] Failed to remove boot at start: %v", err)) bootServiceError = fmt.Sprintf("Failed to remove boot at start: %v", err) } instance.Name = newName - if err := service.SetBootAtStart(instance.ID); err != nil { + if err := sys.SetBootAtStart(instance.ID); err != nil { postLog.Error(fmt.Sprintf("[handleSystemConfigModify] Failed to set boot at start: %v", err)) if bootServiceError != "" { bootServiceError += "; " @@ -437,7 +437,7 @@ func handleSystemConfigModify(w http.ResponseWriter, r *http.Request, instance d bootServiceError += fmt.Sprintf("Failed to set boot at start: %v", err) } } else { - if err := service.RemoveBootAtStart(instance.ID); err != nil { + if err := sys.RemoveBootAtStart(instance.ID); err != nil { postLog.Error(fmt.Sprintf("[handleSystemConfigModify] Failed to remove boot at start: %v", err)) bootServiceError = fmt.Sprintf("Failed to remove boot at start: %v", err) } @@ -523,7 +523,7 @@ func ListInstancesHandler(w http.ResponseWriter, r *http.Request) { "isRunning": false, } - err = service.IsInstanceRunning(inst.ID) + err = sys.IsInstanceRunning(inst.ID) if err != nil { instanceData["isRunning"] = false } else { @@ -590,54 +590,54 @@ func StartInstanceHandler(w http.ResponseWriter, r *http.Request) { return } - initType := service.GetInitSystem() - serviceName, err := database.GetServiceNameByInstanceID(instanceID) + initType := sys.GetInitSystem() + sysName, err := database.GetServiceNameByInstanceID(instanceID) if err != nil { - postLog.Error(fmt.Sprintf("[StartInstanceHandler] Failed to get service name: %v", err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, "Failed to get service name") + postLog.Error(fmt.Sprintf("[StartInstanceHandler] Failed to get sys name: %v", err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, "Failed to get sys name") return } switch initType { case "windows": - if err := service.StartWindowsService(serviceName); err != nil { - postLog.Error(fmt.Sprintf("[StartInstanceHandler] Failed to start Windows service %s: %v", serviceName, err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to start Windows service: %v", err)) + if err := sys.StartWindowsService(sysName); err != nil { + postLog.Error(fmt.Sprintf("[StartInstanceHandler] Failed to start Windows sys %s: %v", sysName, err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to start Windows sys: %v", err)) return } - postLog.Debug(fmt.Sprintf("[StartInstanceHandler] Windows service %s started successfully", serviceName)) + postLog.Debug(fmt.Sprintf("[StartInstanceHandler] Windows sys %s started successfully", sysName)) time.Sleep(time.Millisecond * 200) - if err := service.IsInstanceRunning(instanceID); err != nil { - postLog.Error(fmt.Sprintf("[StartInstanceHandler] Windows service %s failed to start: %v", serviceName, err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to start Windows service: %v", err)) + if err := sys.IsInstanceRunning(instanceID); err != nil { + postLog.Error(fmt.Sprintf("[StartInstanceHandler] Windows sys %s failed to start: %v", sysName, err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to start Windows sys: %v", err)) return } case "systemd": - if err := service.StartSystemdService(serviceName); err != nil { - postLog.Error(fmt.Sprintf("[StartInstanceHandler] Failed to start systemd service %s: %v", serviceName, err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to start systemd service: %v", err)) + if err := sys.StartSystemdService(sysName); err != nil { + postLog.Error(fmt.Sprintf("[StartInstanceHandler] Failed to start systemd sys %s: %v", sysName, err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to start systemd sys: %v", err)) return } - postLog.Debug(fmt.Sprintf("[StartInstanceHandler] Systemd service %s started successfully", serviceName)) + postLog.Debug(fmt.Sprintf("[StartInstanceHandler] Systemd sys %s started successfully", sysName)) time.Sleep(time.Millisecond * 200) - if err := service.IsInstanceRunning(instanceID); err != nil { - postLog.Error(fmt.Sprintf("[StartInstanceHandler] Systemd service %s failed to start: %v", serviceName, err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to start systemd service: %v", err)) + if err := sys.IsInstanceRunning(instanceID); err != nil { + postLog.Error(fmt.Sprintf("[StartInstanceHandler] Systemd sys %s failed to start: %v", sysName, err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to start systemd sys: %v", err)) return } case "init.d": - if err := service.StartInitDService(serviceName); err != nil { - postLog.Error(fmt.Sprintf("[StartInstanceHandler] Failed to start init.d service %s: %v", serviceName, err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to start init.d service: %v", err)) + if err := sys.StartInitDService(sysName); err != nil { + postLog.Error(fmt.Sprintf("[StartInstanceHandler] Failed to start init.d sys %s: %v", sysName, err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to start init.d sys: %v", err)) return } - postLog.Debug(fmt.Sprintf("[StartInstanceHandler] Init.d service %s started successfully", serviceName)) + postLog.Debug(fmt.Sprintf("[StartInstanceHandler] Init.d sys %s started successfully", sysName)) time.Sleep(time.Millisecond * 200) - if err := service.IsInstanceRunning(instanceID); err != nil { - postLog.Error(fmt.Sprintf("[StartInstanceHandler] Init.d service %s failed to start: %v", serviceName, err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to start init.d service: %v", err)) + if err := sys.IsInstanceRunning(instanceID); err != nil { + postLog.Error(fmt.Sprintf("[StartInstanceHandler] Init.d sys %s failed to start: %v", sysName, err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to start init.d sys: %v", err)) return } @@ -647,17 +647,17 @@ func StartInstanceHandler(w http.ResponseWriter, r *http.Request) { } if global.Is.WatchdogConnected { - if !watchdog.AddInstance(serviceName) { - postLog.Warning(fmt.Sprintf("[StartInstanceHandler] Failed to add watchdog instance %s", serviceName)) + if !watchdog.AddInstance(sysName) { + postLog.Warning(fmt.Sprintf("[StartInstanceHandler] Failed to add watchdog instance %s", sysName)) utils.SendSuccessResponse(w, "Instance started successfully but watchdog instance add failed", map[string]interface{}{ "instanceID": instanceID, - "serviceName": serviceName, + "sysName": sysName, }) return } else { utils.SendSuccessResponse(w, "Instance started successfully", map[string]interface{}{ "instanceID": instanceID, - "serviceName": serviceName, + "sysName": sysName, }) } } @@ -718,45 +718,45 @@ func StopInstanceHandler(w http.ResponseWriter, r *http.Request) { return } - initType := service.GetInitSystem() - serviceName, err := database.GetServiceNameByInstanceID(instanceID) + initType := sys.GetInitSystem() + sysName, err := database.GetServiceNameByInstanceID(instanceID) if err != nil { - postLog.Error(fmt.Sprintf("[StopInstanceHandler] Failed to get service name: %v", err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, "Failed to get service name") + postLog.Error(fmt.Sprintf("[StopInstanceHandler] Failed to get sys name: %v", err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, "Failed to get sys name") return } switch initType { case "windows": - if err := service.StopWindowsService(serviceName); err != nil { - postLog.Error(fmt.Sprintf("[StopInstanceHandler] Failed to stop Windows service %s: %v", serviceName, err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to stop Windows service: %v", err)) + if err := sys.StopWindowsService(sysName); err != nil { + postLog.Error(fmt.Sprintf("[StopInstanceHandler] Failed to stop Windows sys %s: %v", sysName, err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to stop Windows sys: %v", err)) return } time.Sleep(time.Millisecond * 200) - if err := service.IsInstanceRunning(instanceID); err == nil { - postLog.Error(fmt.Sprintf("[StopInstanceHandler] Windows service %s failed to stop: %v", serviceName, err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to stop Windows service: %v", err)) + if err := sys.IsInstanceRunning(instanceID); err == nil { + postLog.Error(fmt.Sprintf("[StopInstanceHandler] Windows sys %s failed to stop: %v", sysName, err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to stop Windows sys: %v", err)) return } - postLog.Debug(fmt.Sprintf("[StopInstanceHandler] Windows service %s stopped successfully", serviceName)) + postLog.Debug(fmt.Sprintf("[StopInstanceHandler] Windows sys %s stopped successfully", sysName)) case "systemd": - if err := service.StopSystemdService(serviceName); err != nil { - postLog.Error(fmt.Sprintf("[StopInstanceHandler] Failed to stop systemd service %s: %v", serviceName, err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to stop systemd service: %v", err)) + if err := sys.StopSystemdService(sysName); err != nil { + postLog.Error(fmt.Sprintf("[StopInstanceHandler] Failed to stop systemd sys %s: %v", sysName, err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to stop systemd sys: %v", err)) return } - postLog.Debug(fmt.Sprintf("[StopInstanceHandler] Systemd service %s stopped successfully", serviceName)) + postLog.Debug(fmt.Sprintf("[StopInstanceHandler] Systemd sys %s stopped successfully", sysName)) case "init.d": - if err := service.StopInitDService(serviceName); err != nil { + if err := sys.StopInitDService(sysName); err != nil { time.Sleep(time.Millisecond * 200) - postLog.Error(fmt.Sprintf("[StopInstanceHandler] Failed to stop init.d service %s: %v", serviceName, err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to stop init.d service: %v", err)) + postLog.Error(fmt.Sprintf("[StopInstanceHandler] Failed to stop init.d sys %s: %v", sysName, err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to stop init.d sys: %v", err)) return } - postLog.Debug(fmt.Sprintf("[StopInstanceHandler] Init.d service %s stopped successfully", serviceName)) + postLog.Debug(fmt.Sprintf("[StopInstanceHandler] Init.d sys %s stopped successfully", sysName)) default: utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Unsupported init system: %s", initType)) @@ -764,16 +764,16 @@ func StopInstanceHandler(w http.ResponseWriter, r *http.Request) { } if global.Is.WatchdogConnected { - if !watchdog.RemoveInstance(serviceName) { - postLog.Warning(fmt.Sprintf("[StopInstanceHandler] Failed to remove watchdog instance %s", serviceName)) + if !watchdog.RemoveInstance(sysName) { + postLog.Warning(fmt.Sprintf("[StopInstanceHandler] Failed to remove watchdog instance %s", sysName)) utils.SendSuccessResponse(w, "Instance stopped successfully but watchdog instance remove failed", map[string]interface{}{ "instanceID": instanceID, - "serviceName": serviceName, + "sysName": sysName, }) } else { utils.SendSuccessResponse(w, "Instance stopped successfully", map[string]interface{}{ "instanceID": instanceID, - "serviceName": serviceName, + "sysName": sysName, }) } } @@ -834,47 +834,47 @@ func RestartInstanceHandler(w http.ResponseWriter, r *http.Request) { return } - initType := service.GetInitSystem() - serviceName, err := database.GetServiceNameByInstanceID(instanceID) + initType := sys.GetInitSystem() + sysName, err := database.GetServiceNameByInstanceID(instanceID) if err != nil { - postLog.Error(fmt.Sprintf("[RestartInstanceHandler] Failed to get service name: %v", err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, "Failed to get service name") + postLog.Error(fmt.Sprintf("[RestartInstanceHandler] Failed to get sys name: %v", err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, "Failed to get sys name") return } switch initType { case "windows": - if err := service.RestartWindowsService(serviceName); err != nil { - postLog.Error(fmt.Sprintf("[RestartInstanceHandler] Failed to restart Windows service %s: %v", serviceName, err)) + if err := sys.RestartWindowsService(sysName); err != nil { + postLog.Error(fmt.Sprintf("[RestartInstanceHandler] Failed to restart Windows sys %s: %v", sysName, err)) time.Sleep(time.Millisecond * 200) - if err := service.IsInstanceRunning(instanceID); err != nil { - postLog.Error(fmt.Sprintf("[RestartInstanceHandler] Windows service %s restarted but is not running: %v", serviceName, err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Windows service restarted but is not running: %v", err)) + if err := sys.IsInstanceRunning(instanceID); err != nil { + postLog.Error(fmt.Sprintf("[RestartInstanceHandler] Windows sys %s restarted but is not running: %v", sysName, err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Windows sys restarted but is not running: %v", err)) return } - postLog.Debug(fmt.Sprintf("[RestartInstanceHandler] Windows service %s restarted successfully", serviceName)) + postLog.Debug(fmt.Sprintf("[RestartInstanceHandler] Windows sys %s restarted successfully", sysName)) } case "systemd": - if err := service.RestartSystemdService(serviceName); err != nil { + if err := sys.RestartSystemdService(sysName); err != nil { time.Sleep(time.Millisecond * 200) - if err := service.IsInstanceRunning(instanceID); err != nil { - postLog.Error(fmt.Sprintf("[RestartInstanceHandler] Failed to check if systemd service %s is running after restart: %v", serviceName, err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to check if systemd service is running after restart: %v", err)) + if err := sys.IsInstanceRunning(instanceID); err != nil { + postLog.Error(fmt.Sprintf("[RestartInstanceHandler] Failed to check if systemd sys %s is running after restart: %v", sysName, err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to check if systemd sys is running after restart: %v", err)) return } - postLog.Debug(fmt.Sprintf("[RestartInstanceHandler] Systemd service %s restarted successfully", serviceName)) + postLog.Debug(fmt.Sprintf("[RestartInstanceHandler] Systemd sys %s restarted successfully", sysName)) } case "init.d": - if err := service.RestartInitDService(serviceName); err != nil { + if err := sys.RestartInitDService(sysName); err != nil { time.Sleep(time.Millisecond * 200) - if err := service.IsInstanceRunning(instanceID); err != nil { - postLog.Error(fmt.Sprintf("[RestartInstanceHandler] Failed to check init.d service %s status after restart: %v", serviceName, err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to check init.d service status after restart: %v", err)) + if err := sys.IsInstanceRunning(instanceID); err != nil { + postLog.Error(fmt.Sprintf("[RestartInstanceHandler] Failed to check init.d sys %s status after restart: %v", sysName, err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Failed to check init.d sys status after restart: %v", err)) return } - postLog.Debug(fmt.Sprintf("[RestartInstanceHandler] Init.d service %s restarted successfully", serviceName)) + postLog.Debug(fmt.Sprintf("[RestartInstanceHandler] Init.d sys %s restarted successfully", sysName)) } default: @@ -884,7 +884,7 @@ func RestartInstanceHandler(w http.ResponseWriter, r *http.Request) { utils.SendSuccessResponse(w, "Instance restarted successfully", map[string]interface{}{ "instanceID": instanceID, - "serviceName": serviceName, + "sysName": sysName, }) postLog.Info(fmt.Sprintf("[RestartInstanceHandler] Instance %d restarted successfully", instanceID)) } @@ -926,7 +926,7 @@ func GetInstanceStatusHandler(w http.ResponseWriter, r *http.Request) { return } - err = service.IsInstanceRunning(instanceID) + err = sys.IsInstanceRunning(instanceID) isRunning := err == nil utils.SendSuccessResponse(w, "Instance status retrieved successfully", map[string]interface{}{ @@ -979,10 +979,10 @@ func GetInstanceInfoHandler(w http.ResponseWriter, r *http.Request) { return } - serviceName, err := database.GetServiceNameByInstanceID(instanceID) + sysName, err := database.GetServiceNameByInstanceID(instanceID) if err != nil { - postLog.Error(fmt.Sprintf("[GetInstanceInfoHandler] Failed to get service name: %v", err)) - utils.SendErrorResponse(w, http.StatusInternalServerError, "Failed to get service name") + postLog.Error(fmt.Sprintf("[GetInstanceInfoHandler] Failed to get sys name: %v", err)) + utils.SendErrorResponse(w, http.StatusInternalServerError, "Failed to get sys name") return } @@ -1000,12 +1000,12 @@ func GetInstanceInfoHandler(w http.ResponseWriter, r *http.Request) { return } - err = service.IsInstanceRunning(instanceID) + err = sys.IsInstanceRunning(instanceID) isRunning := err == nil response := map[string]interface{}{ "name": instance.Name, - "serviceName": serviceName, + "sysName": sysName, "createdAt": instance.CreatedAt.Format(time.RFC3339), "createdBy": instance.CreatedBy, "isRunning": isRunning, diff --git a/main.go b/main.go index 570e179..852aa70 100644 --- a/main.go +++ b/main.go @@ -12,7 +12,7 @@ import ( "super-frpc/frpLogger" "super-frpc/global" "super-frpc/postLog" - "super-frpc/service" + "super-frpc/sys" "super-frpc/session" "super-frpc/utils" "super-frpc/watchdog" @@ -38,7 +38,7 @@ func main() { postLog.Info(fmt.Sprintf("Created default config file at %s", *global.ConfigPath)) } - err := config.LoadConfig(*global.ConfigPath, service.GetInitSystem) + err := config.LoadConfig(*global.ConfigPath, sys.GetInitSystem) if err != nil { postLog.Fatal(fmt.Sprintf("Failed to load config: %v", err)) } diff --git a/service/service.go b/sys/core.go similarity index 99% rename from service/service.go rename to sys/core.go index 64cdd67..d49ff91 100644 --- a/service/service.go +++ b/sys/core.go @@ -1,4 +1,4 @@ -package service +package sys import ( "fmt" diff --git a/web/handler.go b/web/handler.go index e10a5e1..15f831e 100644 --- a/web/handler.go +++ b/web/handler.go @@ -45,7 +45,7 @@ func ServeStatic(w http.ResponseWriter, r *http.Request) { } setContentType(w, path.Ext(filePath)) - http.ServeContent(w, r, filePath, stat.ModTime(), f.(http.File)) + http.ServeContent(w, r, filePath, stat.ModTime(), f) return }