Super-frpc/backend
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

style(service): modify package name "service" to "sys"

Browse Source
This commit is contained in:
NanamiAdmin
2026-05-07 19:28:49 +08:00
parent a0ef35627b
commit 44195c9f26
4 changed files with 97 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files
handlers/instance.go
+93 -93
View File
@@ -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,