feat: compatible with openrc and sysvinit (#10723)

agent/utils/ai_tools/gpu/gpu.go

@@ -26,7 +26,7 @@ func (n NvidiaSMI) LoadGpuInfo() (*common.GpuInfo, error) {
 	cmdMgr := cmd.NewCommandMgr(cmd.WithTimeout(5 * time.Second))
 	itemData, err := cmdMgr.RunWithStdoutBashC("nvidia-smi -q -x")
 	if err != nil {
-		return nil, fmt.Errorf("calling nvidia-smi failed, err: %w", err)
+		return nil, fmt.Errorf("calling nvidia-smi failed, %v", err)
 	}
 	data := []byte(itemData)
 	version := "v11"

agent/utils/ai_tools/xpu/xpu.go

@@ -8,7 +8,7 @@ import (
 	"sync"
 	"time"
 
-	baseGlobal "github.com/1Panel-dev/1Panel/agent/global"
+	"github.com/1Panel-dev/1Panel/agent/global"
 	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
 )
 
@@ -45,31 +45,31 @@ func (x XpuSMI) loadDeviceData(device Device, wg *sync.WaitGroup, res *[]XPUSimp
 	wgCmd.Wait()
 
 	if xpuErr != nil {
-		baseGlobal.LOG.Errorf("calling xpu-smi discovery failed for device %d, err: %v\n", device.DeviceID, xpuErr)
+		global.LOG.Errorf("calling xpu-smi discovery failed for device %d, %v", device.DeviceID, xpuErr)
 		return
 	}
 
 	var info Device
 	if err := json.Unmarshal([]byte(xpuData), &info); err != nil {
-		baseGlobal.LOG.Errorf("xpuData json unmarshal failed for device %d, err: %v\n", device.DeviceID, err)
+		global.LOG.Errorf("xpuData json unmarshal failed for device %d, err: %v", device.DeviceID, err)
 		return
 	}
 
 	bytes, err := strconv.ParseInt(info.MemoryPhysicalSizeByte, 10, 64)
 	if err != nil {
-		baseGlobal.LOG.Errorf("Error parsing memory size for device %d, err: %v\n", device.DeviceID, err)
+		global.LOG.Errorf("Error parsing memory size for device %d, err: %v", device.DeviceID, err)
 		return
 	}
 	xpu.Memory = fmt.Sprintf("%.1f MB", float64(bytes)/(1024*1024))
 
 	if statsErr != nil {
-		baseGlobal.LOG.Errorf("calling xpu-smi stats failed for device %d, err: %v\n", device.DeviceID, statsErr)
+		global.LOG.Errorf("calling xpu-smi stats failed for device %d, err: %v", device.DeviceID, statsErr)
 		return
 	}
 
 	var stats DeviceStats
 	if err := json.Unmarshal([]byte(statsData), &stats); err != nil {
-		baseGlobal.LOG.Errorf("statsData json unmarshal failed for device %d, err: %v\n", device.DeviceID, err)
+		global.LOG.Errorf("statsData json unmarshal failed for device %d, err: %v", device.DeviceID, err)
 		return
 	}
 
@@ -95,7 +95,7 @@ func (x XpuSMI) LoadDashData() ([]XPUSimpleInfo, error) {
 	cmdMgr := cmd.NewCommandMgr(cmd.WithTimeout(5 * time.Second))
 	data, err := cmdMgr.RunWithStdoutBashC("xpu-smi discovery -j")
 	if err != nil {
-		return nil, fmt.Errorf("calling xpu-smi failed, err: %w", err)
+		return nil, fmt.Errorf("calling xpu-smi failed, %v", err)
 	}
 
 	var deviceInfo DeviceInfo
@@ -124,7 +124,7 @@ func (x XpuSMI) LoadGpuInfo() (*XpuInfo, error) {
 	cmdMgr := cmd.NewCommandMgr(cmd.WithTimeout(5 * time.Second))
 	data, err := cmdMgr.RunWithStdoutBashC("xpu-smi discovery -j")
 	if err != nil {
-		return nil, fmt.Errorf("calling xpu-smi  failed, err: %w", err)
+		return nil, fmt.Errorf("calling xpu-smi  failed, %v", err)
 	}
 	var deviceInfo DeviceInfo
 	if err := json.Unmarshal([]byte(data), &deviceInfo); err != nil {
@@ -146,7 +146,7 @@ func (x XpuSMI) LoadGpuInfo() (*XpuInfo, error) {
 
 	processData, err := cmdMgr.RunWithStdoutBashC("xpu-smi ps -j")
 	if err != nil {
-		return nil, fmt.Errorf("calling xpu-smi ps failed, err: %w", err)
+		return nil, fmt.Errorf("calling xpu-smi ps failed, %s", err)
 	}
 	var psList DeviceUtilByProcList
 	if err := json.Unmarshal([]byte(processData), &psList); err != nil {
@@ -205,13 +205,13 @@ func (x XpuSMI) loadDeviceInfo(device Device, wg *sync.WaitGroup, res *XpuInfo,
 	wgCmd.Wait()
 
 	if xpuErr != nil {
-		baseGlobal.LOG.Errorf("calling xpu-smi discovery failed for device %d, err: %v\n", device.DeviceID, xpuErr)
+		global.LOG.Errorf("calling xpu-smi discovery failed for device %d, %v", device.DeviceID, xpuErr)
 		return
 	}
 
 	var info Device
 	if err := json.Unmarshal([]byte(xpuData), &info); err != nil {
-		baseGlobal.LOG.Errorf("xpuData json unmarshal failed for device %d, err: %v\n", device.DeviceID, err)
+		global.LOG.Errorf("xpuData json unmarshal failed for device %d, err: %v", device.DeviceID, err)
 		return
 	}
 
@@ -220,20 +220,20 @@ func (x XpuSMI) loadDeviceInfo(device Device, wg *sync.WaitGroup, res *XpuInfo,
 
 	bytes, err := strconv.ParseInt(info.MemoryPhysicalSizeByte, 10, 64)
 	if err != nil {
-		baseGlobal.LOG.Errorf("Error parsing memory size for device %d, err: %v\n", device.DeviceID, err)
+		global.LOG.Errorf("Error parsing memory size for device %d, err: %v", device.DeviceID, err)
 		return
 	}
 	xpu.Basic.Memory = fmt.Sprintf("%.1f MB", float64(bytes)/(1024*1024))
 	xpu.Basic.FreeMemory = info.MemoryFreeSizeByte
 
 	if statsErr != nil {
-		baseGlobal.LOG.Errorf("calling xpu-smi stats failed for device %d, err: %v\n", device.DeviceID, statsErr)
+		global.LOG.Errorf("calling xpu-smi stats failed for device %d, err: %v", device.DeviceID, statsErr)
 		return
 	}
 
 	var stats DeviceStats
 	if err := json.Unmarshal([]byte(statsData), &stats); err != nil {
-		baseGlobal.LOG.Errorf("statsData json unmarshal failed for device %d, err: %v\n", device.DeviceID, err)
+		global.LOG.Errorf("statsData json unmarshal failed for device %d, err: %v", device.DeviceID, err)
 		return
 	}
 

agent/utils/clam/clam.go

@@ -14,7 +14,7 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/global"
 	"github.com/1Panel-dev/1Panel/agent/i18n"
 	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
-	"github.com/1Panel-dev/1Panel/agent/utils/systemctl"
+	"github.com/1Panel-dev/1Panel/agent/utils/controller"
 	"github.com/robfig/cron/v3"
 )
 
@@ -34,37 +34,13 @@ func AddScanTask(taskItem *task.Task, clam model.Clam, timeNow string) {
 		}
 		taskItem.Logf("clamdscan --fdpass %s %s", strategy, clam.Path)
 		mgr := cmd.NewCommandMgr(cmd.WithIgnoreExist1(), cmd.WithTimeout(time.Duration(clam.Timeout)*time.Second), cmd.WithTask(*taskItem))
-		stdout, err := mgr.RunWithStdoutBashCf("clamdscan --fdpass %s %s", strategy, clam.Path)
-		if err != nil {
-			return fmt.Errorf("clamdscan failed, stdout: %v, err: %v", stdout, err)
+		if err := mgr.RunBashCf("clamdscan --fdpass %s %s", strategy, clam.Path); err != nil {
+			return fmt.Errorf("clamdscan failed, %v", err)
 		}
 		return nil
 	}, nil)
 }
 
-func CheckClamIsActive(withCheck bool, clamRepo repo.IClamRepo) bool {
-	if withCheck {
-		isActive := false
-		exist1, _ := systemctl.IsExist(constant.ClamServiceNameCentOs)
-		if exist1 {
-			isActive, _ = systemctl.IsActive(constant.ClamServiceNameCentOs)
-		}
-		exist2, _ := systemctl.IsExist(constant.ClamServiceNameUbuntu)
-		if exist2 {
-			isActive, _ = systemctl.IsActive(constant.ClamServiceNameUbuntu)
-		}
-		if isActive {
-			return true
-		}
-	}
-	clams, _ := clamRepo.List(repo.WithByStatus(constant.StatusEnable))
-	for i := 0; i < len(clams); i++ {
-		global.Cron.Remove(cron.EntryID(clams[i].EntryID))
-		_ = clamRepo.Update(clams[i].ID, map[string]interface{}{"status": constant.StatusDisable, "entry_id": 0})
-	}
-	return false
-}
-
 func AnalysisFromLog(pathItem string, record *model.ClamRecord) {
 	file, err := os.ReadFile(pathItem)
 	if err != nil {
@@ -86,3 +62,22 @@ func AnalysisFromLog(pathItem string, record *model.ClamRecord) {
 		}
 	}
 }
+
+func StopAllClamJob(withCheck bool, clamRepo repo.IClamRepo) bool {
+	if withCheck {
+		isActive := false
+		isexist, _ := controller.CheckExist("clam")
+		if isexist {
+			isActive, _ = controller.CheckActive("clam")
+		}
+		if isActive {
+			return false
+		}
+	}
+	clams, _ := clamRepo.List(repo.WithByStatus(constant.StatusEnable))
+	for i := 0; i < len(clams); i++ {
+		global.Cron.Remove(cron.EntryID(clams[i].EntryID))
+		_ = clamRepo.Update(clams[i].ID, map[string]interface{}{"status": constant.StatusDisable, "entry_id": 0})
+	}
+	return true
+}

agent/utils/cmd/cmdx.go

@@ -70,16 +70,14 @@ func (c *CommandHelper) RunBashCWithArgs(arg ...string) error {
 }
 
 func (c *CommandHelper) RunBashC(command string) error {
-	std, err := c.run("bash", "-c", command)
-	if err != nil {
-		return fmt.Errorf("handle failed, std: %s, err: %v", std, err)
+	if _, err := c.run("bash", "-c", command); err != nil {
+		return err
 	}
 	return nil
 }
 func (c *CommandHelper) RunBashCf(command string, arg ...interface{}) error {
-	std, err := c.run("bash", "-c", fmt.Sprintf(command, arg...))
-	if err != nil {
-		return fmt.Errorf("handle failed, std: %s, err: %v", std, err)
+	if _, err := c.run("bash", "-c", fmt.Sprintf(command, arg...)); err != nil {
+		return err
 	}
 	return nil
 }
@@ -237,16 +235,16 @@ func handleErr(stdout, stderr bytes.Buffer, ignoreExist1 bool, err error) (strin
 			}
 		}
 	}
-	errMsg := ""
-	if len(stderr.String()) != 0 {
-		errMsg = fmt.Sprintf("stderr: %s", stderr.String())
+	outItem := stdout.String()
+	errItem := stderr.String()
+	if len(errItem) != 0 && len(outItem) != 0 {
+		return outItem, fmt.Errorf("stdout: %s; stderr: %s, err: %v", outItem, errItem, err)
 	}
-	if len(stdout.String()) != 0 {
-		if len(errMsg) != 0 {
-			errMsg = fmt.Sprintf("%s; stdout: %s", errMsg, stdout.String())
-		} else {
-			errMsg = fmt.Sprintf("stdout: %s", stdout.String())
-		}
+	if len(errItem) != 0 {
+		return outItem, fmt.Errorf("stderr: %s, err: %v", errItem, err)
 	}
-	return errMsg, err
+	if len(outItem) != 0 {
+		return outItem, fmt.Errorf("stdout: %s, err: %v", outItem, err)
+	}
+	return "", err
 }

agent/utils/common/common.go

@@ -18,7 +18,6 @@ import (
 	"github.com/gin-gonic/gin"
 
 	"github.com/1Panel-dev/1Panel/agent/buserr"
-	"github.com/1Panel-dev/1Panel/agent/global"
 	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
 	"golang.org/x/net/idna"
 )
@@ -398,28 +397,6 @@ func HandleIPList(content string) ([]string, error) {
 	return res, nil
 }
 
-func RestartService(core, agent, reload bool) {
-	command := ""
-	if reload {
-		command = "systemctl daemon-reload && "
-	}
-	switch {
-	case core && agent:
-		command += "systemctl restart 1panel-core.service && systemctl restart 1panel-agent.service"
-	case core:
-		command += "systemctl restart 1panel-core.service"
-	case agent:
-		command += "systemctl restart 1panel-agent.service"
-	default:
-		return
-	}
-	cmdMgr := cmd.NewCommandMgr(cmd.WithTimeout(1 * time.Second))
-	std, err := cmdMgr.RunWithStdoutBashC(command)
-	if err != nil {
-		global.LOG.Errorf("restart 1panel service failed, err: %v, std: %s", err, std)
-	}
-}
-
 func GetSystemVersion(versionString string) string {
 	re := regexp.MustCompile(`v(\d+\.\d+\.\d+)`)
 	match := re.FindStringSubmatch(versionString)

agent/utils/controller/controller.go

@@ -0,0 +1,197 @@
+package controller
+
+import (
+	"errors"
+	"fmt"
+	"os/exec"
+	"strings"
+
+	"github.com/1Panel-dev/1Panel/agent/global"
+	"github.com/1Panel-dev/1Panel/agent/utils/controller/manager"
+)
+
+type Controller interface {
+	Name() string
+	IsActive(serviceName string) (bool, error)
+	IsEnable(serviceName string) (bool, error)
+	IsExist(serviceName string) (bool, error)
+	Status(serviceName string) (string, error)
+
+	Operate(operate, serviceName string) error
+
+	Reload() error
+}
+
+func New() (Controller, error) {
+	managerOptions := []string{"systemd", "openrc", "sysvinit"}
+	for _, item := range managerOptions {
+		if _, err := exec.LookPath(item); err != nil {
+			continue
+		}
+		switch item {
+		case "systemd":
+			return manager.NewSystemd(), nil
+		case "openrc":
+			return manager.NewOpenrc(), nil
+		case "sysvinit":
+			return manager.NewSysvinit(), nil
+		}
+	}
+	return nil, errors.New("not support such manager initializatio")
+}
+
+func Handle(operate, serviceName string) error {
+	service, err := LoadServiceName(serviceName)
+	if err != nil {
+		return err
+	}
+	client, err := New()
+	if err != nil {
+		return err
+	}
+	return client.Operate(operate, service)
+}
+func HandleStart(serviceName string) error {
+	service, err := LoadServiceName(serviceName)
+	if err != nil {
+		return err
+	}
+	return Handle("start", service)
+}
+func HandleStop(serviceName string) error {
+	service, err := LoadServiceName(serviceName)
+	if err != nil {
+		return err
+	}
+	return Handle("stop", service)
+}
+func HandleRestart(serviceName string) error {
+	service, err := LoadServiceName(serviceName)
+	if err != nil {
+		return err
+	}
+	return Handle("restart", service)
+}
+
+func CheckExist(serviceName string) (bool, error) {
+	service, err := LoadServiceName(serviceName)
+	if err != nil {
+		return false, err
+	}
+	client, err := New()
+	if err != nil {
+		return false, err
+	}
+	b, er := client.IsExist(service)
+	return b, er
+}
+func CheckActive(serviceName string) (bool, error) {
+	service, err := LoadServiceName(serviceName)
+	if err != nil {
+		return false, err
+	}
+	client, err := New()
+	if err != nil {
+		return false, err
+	}
+	return client.IsActive(service)
+}
+func CheckEnable(serviceName string) (bool, error) {
+	service, err := LoadServiceName(serviceName)
+	if err != nil {
+		return false, err
+	}
+	client, err := New()
+	if err != nil {
+		return false, err
+	}
+	return client.IsEnable(service)
+}
+
+func Reload() error {
+	client, err := New()
+	if err != nil {
+		return err
+	}
+	return client.Reload()
+}
+
+func RestartPanel(core, agent, reload bool) {
+	client, err := New()
+	if err != nil {
+		global.LOG.Errorf("load client for controller failed, err: %v", err)
+		return
+	}
+	if reload {
+		if err := client.Reload(); err != nil {
+			global.LOG.Errorf("restart 1panel service failed, err: %v", err)
+			return
+		}
+	}
+	if agent {
+		if err := client.Operate("restart", "1panel-agent"); err != nil {
+			global.LOG.Errorf("restart 1panel agent service failed, err: %v", err)
+			return
+		}
+	}
+	if core {
+		if err := client.Operate("restart", "1panel-core"); err != nil {
+			global.LOG.Errorf("restart 1panel core service failed, err: %v", err)
+			return
+		}
+	}
+}
+
+func LoadServiceName(keyword string) (string, error) {
+	client, err := New()
+	if err != nil {
+		return "", err
+	}
+
+	processedName := loadProcessedName(client.Name(), keyword)
+	exist, err := client.IsExist(processedName)
+	if exist {
+		return processedName, nil
+	}
+	alistName := loadFromPredefined(client, keyword)
+	if len(alistName) != 0 {
+		return alistName, nil
+	}
+	return "", fmt.Errorf("find such service for %s failed", keyword)
+}
+
+func loadProcessedName(mgr, keyword string) string {
+	keyword = strings.ToLower(keyword)
+	if strings.HasSuffix(keyword, ".service.socket") {
+		keyword = strings.TrimSuffix(keyword, ".service.socket") + ".socket"
+	}
+	if mgr != "systemd" {
+		keyword = strings.TrimSuffix(keyword, ".service")
+		return keyword
+	}
+	if !strings.HasSuffix(keyword, ".service") && !strings.HasSuffix(keyword, ".socket") {
+		keyword += ".service"
+	}
+	return keyword
+}
+
+func loadFromPredefined(mgr Controller, keyword string) string {
+	predefinedMap := map[string][]string{
+		"clam":         {"clamav-daemon.service", "clamd@scan.service", "clamd"},
+		"freshclam":    {"clamav-freshclam.service", "freshclam.service"},
+		"fail2ban":     {"fail2ban.service", "fail2ban"},
+		"supervisor":   {"supervisord.service", "supervisor.service", "supervisord", "supervisor"},
+		"ssh":          {"sshd.service", "ssh.service", "sshd", "ssh"},
+		"1panel-core":  {"1panel-core.service", "1panel-cored"},
+		"1panel-agent": {"1panel-agent.service", "1panel-agentd"},
+		"docker":       {"docker.service", "dockerd"},
+	}
+	if val, ok := predefinedMap[keyword]; ok {
+		for _, item := range val {
+			if exist, _ := mgr.IsExist(item); exist {
+				return item
+			}
+		}
+	}
+	return ""
+}

agent/utils/controller/manager/common.go

@@ -0,0 +1,25 @@
+package manager
+
+import (
+	"errors"
+	"strings"
+	"time"
+
+	"github.com/1Panel-dev/1Panel/agent/global"
+	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
+)
+
+func handlerErr(out string, err error) error {
+	if err != nil {
+		if out != "" {
+			return errors.New(out)
+		}
+		return err
+	}
+	return nil
+}
+
+func run(name string, args ...string) (string, error) {
+	global.LOG.Debugf("handle with controller `%s %s`", name, strings.Join(args, " "))
+	return cmd.NewCommandMgr(cmd.WithTimeout(10*time.Second)).RunWithStdoutBashCf("LANGUAGE=en_US:en %s %s", name, strings.Join(args, " "))
+}

agent/utils/controller/manager/openrc.go

@@ -0,0 +1,61 @@
+package manager
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
+)
+
+type Openrc struct{ toolCmd string }
+
+func NewOpenrc() *Openrc {
+	return &Openrc{toolCmd: "rc-service"}
+}
+
+func (s *Openrc) Name() string {
+	return "openrc"
+}
+func (s *Openrc) IsActive(serviceName string) (bool, error) {
+	out, err := cmd.RunDefaultWithStdoutBashCf("if service %s status >/dev/null 2>&1; then echo 'active'; else echo 'inactive'; fi", serviceName)
+	if err != nil {
+		return false, err
+	}
+	return out == "active\n", nil
+}
+func (s *Openrc) IsEnable(serviceName string) (bool, error) {
+	out, err := cmd.RunDefaultWithStdoutBashCf("if ls /etc/rc*.d/S*%s >/dev/null 2>&1; then echo 'enabled'; else echo 'disabled'; fi", serviceName)
+	if err != nil {
+		return false, err
+	}
+	return out == "enabled\n", nil
+}
+func (s *Openrc) IsExist(serviceName string) (bool, error) {
+	_, err := os.Stat(filepath.Join("/etc/init.d", serviceName))
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("stat /etc/init.d/%s failed: %w", serviceName, err)
+	}
+	return true, nil
+}
+func (s *Openrc) Status(serviceName string) (string, error) {
+	return run(s.toolCmd, serviceName, "status")
+}
+
+func (s *Openrc) Operate(operate, serviceName string) error {
+	switch operate {
+	case "enable":
+		return handlerErr(run("rc-update", "add", serviceName, "default"))
+	case "disable":
+		return handlerErr(run("rc-update", "del", serviceName, "default"))
+	default:
+		return handlerErr(run(s.toolCmd, serviceName, operate))
+	}
+}
+
+func (s *Openrc) Reload() error {
+	return nil
+}

agent/utils/controller/manager/snap.go

@@ -0,0 +1,54 @@
+package manager
+
+import (
+	"strings"
+)
+
+type Snap struct{ toolCmd string }
+
+func NewSnap() *Snap {
+	return &Snap{toolCmd: "snap"}
+}
+
+func (s *Snap) IsExist(serviceName string) bool {
+	out, err := run(s.toolCmd, "services")
+	if err != nil {
+		return false
+	}
+	return strings.Contains(out, serviceName)
+}
+
+func (s *Snap) IsActive(serviceName string) bool {
+	out, err := run(s.toolCmd, "services")
+	if err != nil {
+		return false
+	}
+	lines := strings.Split(out, "\n")
+	for _, line := range lines {
+		if strings.Contains(line, serviceName) && strings.Contains(line, "active") {
+			return true
+		}
+	}
+	return false
+}
+
+func (s *Snap) IsEnable(serviceName string) bool {
+	out, err := run(s.toolCmd, "services")
+	if err != nil {
+		return false
+	}
+	lines := strings.Split(out, "\n")
+	for _, line := range lines {
+		if strings.Contains(line, serviceName) && strings.Contains(line, "enabled") {
+			return true
+		}
+	}
+	return false
+}
+
+func (s *Snap) Operate(operate, serviceName string) error {
+	if s.IsExist(serviceName) {
+		return handlerErr(run(s.toolCmd, operate, serviceName))
+	}
+	return nil
+}

agent/utils/controller/manager/systemd.go

@@ -0,0 +1,75 @@
+package manager
+
+import (
+	"strings"
+)
+
+type Systemd struct{ toolCmd string }
+
+func NewSystemd() *Systemd {
+	return &Systemd{toolCmd: "systemctl"}
+}
+
+func (s *Systemd) Name() string {
+	return "systemd"
+}
+func (s *Systemd) IsActive(serviceName string) (bool, error) {
+	out, err := run(s.toolCmd, "is-active", serviceName)
+	if err != nil && out != "inactive\n" {
+		if NewSnap().IsActive(serviceName) {
+			return true, nil
+		}
+		return false, err
+	}
+	return out == "active\n", nil
+}
+
+func (s *Systemd) IsEnable(serviceName string) (bool, error) {
+	out, err := run(s.toolCmd, "is-enabled", serviceName)
+	if err != nil && out != "disabled\n" {
+		if serviceName == "sshd" && out == "alias\n" {
+			return s.IsEnable("ssh")
+		}
+		if NewSnap().IsEnable(serviceName) {
+			return true, nil
+		}
+		return false, err
+	}
+	return out == "enabled\n", nil
+}
+
+func (s *Systemd) IsExist(serviceName string) (bool, error) {
+	out, err := run(s.toolCmd, "is-enabled", serviceName)
+	if err != nil && out != "enabled\n" {
+		if strings.Contains(out, "disabled") {
+			return true, err
+		}
+		if NewSnap().IsExist(serviceName) {
+			return true, nil
+		}
+		return false, err
+	}
+	return true, err
+}
+
+func (s *Systemd) Status(serviceName string) (string, error) {
+	return run(s.toolCmd, "status", serviceName)
+}
+func (s *Systemd) Operate(operate, serviceName string) error {
+	out, err := run(s.toolCmd, operate, serviceName)
+	if err != nil {
+		if serviceName == "sshd" && strings.Contains(out, "alias name or linked unit file") {
+			return s.Operate(operate, "ssh")
+		}
+		if err := NewSnap().Operate(operate, serviceName); err == nil {
+			return nil
+		}
+		return handlerErr(run(s.toolCmd, operate, serviceName))
+	}
+	return nil
+}
+
+func (s *Systemd) Reload() error {
+	out, err := run(s.toolCmd, "daemon-reload")
+	return handlerErr(out, err)
+}

agent/utils/controller/manager/sysvinit.go

@@ -0,0 +1,54 @@
+package manager
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
+)
+
+type Sysvinit struct{ toolCmd string }
+
+func NewSysvinit() *Sysvinit {
+	return &Sysvinit{toolCmd: "service"}
+}
+
+func (s *Sysvinit) Name() string {
+	return "sysvinit"
+}
+func (s *Sysvinit) IsActive(serviceName string) (bool, error) {
+	out, err := cmd.RunDefaultWithStdoutBashCf("if service %s status >/dev/null 2>&1; then echo 'active'; else echo 'inactive'; fi", serviceName)
+	if err != nil {
+		return false, err
+	}
+	return out == "active\n", nil
+}
+func (s *Sysvinit) IsEnable(serviceName string) (bool, error) {
+	out, err := cmd.RunDefaultWithStdoutBashCf("if ls /etc/rc*.d/S*%s >/dev/null 2>&1; then echo 'enabled'; else echo 'disabled'; fi", serviceName)
+	if err != nil {
+		return false, err
+	}
+	return out == "enabled\n", nil
+}
+func (s *Sysvinit) IsExist(serviceName string) (bool, error) {
+	_, err := os.Stat(filepath.Join("/etc/init.d", serviceName))
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("stat /etc/init.d/%s failed: %w", serviceName, err)
+	}
+	return true, nil
+}
+func (s *Sysvinit) Status(serviceName string) (string, error) {
+	return run(s.toolCmd, serviceName, "status")
+}
+
+func (s *Sysvinit) Operate(operate, serviceName string) error {
+	return handlerErr(run(s.toolCmd, serviceName, operate))
+}
+
+func (s *Sysvinit) Reload() error {
+	return nil
+}

agent/utils/files/file_op.go

@@ -30,7 +30,6 @@ import (
 
 	"github.com/1Panel-dev/1Panel/agent/global"
 	"github.com/mholt/archiver/v4"
-	"github.com/pkg/errors"
 	"github.com/spf13/afero"
 )
 
@@ -178,10 +177,7 @@ func (f FileOp) ChownR(dst string, uid string, gid string, sub bool) error {
 		cmdStr = fmt.Sprintf(`chown -R %s:%s "%s"`, uid, gid, dst)
 	}
 	cmdMgr := cmd.NewCommandMgr(cmd.WithTimeout(10 * time.Second))
-	if msg, err := cmdMgr.RunWithStdoutBashC(cmdStr); err != nil {
-		if msg != "" {
-			return errors.New(msg)
-		}
+	if err := cmdMgr.RunBashC(cmdStr); err != nil {
 		return err
 	}
 	return nil
@@ -193,10 +189,7 @@ func (f FileOp) ChmodR(dst string, mode int64, sub bool) error {
 		cmdStr = fmt.Sprintf(`%s chmod -R %v "%s"`, cmd.SudoHandleCmd(), fmt.Sprintf("%04o", mode), dst)
 	}
 	cmdMgr := cmd.NewCommandMgr(cmd.WithTimeout(10 * time.Second))
-	if msg, err := cmdMgr.RunWithStdoutBashC(cmdStr); err != nil {
-		if msg != "" {
-			return errors.New(msg)
-		}
+	if err := cmdMgr.RunBashC(cmdStr); err != nil {
 		return err
 	}
 	return nil
@@ -208,10 +201,7 @@ func (f FileOp) ChmodRWithMode(dst string, mode fs.FileMode, sub bool) error {
 		cmdStr = fmt.Sprintf(`%s chmod -R %v "%s"`, cmd.SudoHandleCmd(), fmt.Sprintf("%o", mode.Perm()), dst)
 	}
 	cmdMgr := cmd.NewCommandMgr(cmd.WithTimeout(10 * time.Second))
-	if msg, err := cmdMgr.RunWithStdoutBashC(cmdStr); err != nil {
-		if msg != "" {
-			return errors.New(msg)
-		}
+	if err := cmdMgr.RunBashC(cmdStr); err != nil {
 		return err
 	}
 	return nil

agent/utils/firewall/client/firewalld.go

@@ -9,6 +9,7 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/buserr"
 	"github.com/1Panel-dev/1Panel/agent/global"
 	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
+	"github.com/1Panel-dev/1Panel/agent/utils/controller"
 )
 
 var ForwardListRegex = regexp.MustCompile(`^port=(\d{1,5}):proto=(.+?):toport=(\d{1,5}):toaddr=(.*)$`)
@@ -31,39 +32,35 @@ func (f *Firewall) Status() (bool, error) {
 func (f *Firewall) Version() (string, error) {
 	stdout, err := cmd.RunDefaultWithStdoutBashC("LANGUAGE=en_US:en firewall-cmd --version")
 	if err != nil {
-		return "", fmt.Errorf("load the firewall version failed, err: %s", stdout)
+		return "", fmt.Errorf("load the firewall version failed, %v", err)
 	}
 	return strings.ReplaceAll(stdout, "\n ", ""), nil
 }
 
 func (f *Firewall) Start() error {
-	stdout, err := cmd.RunDefaultWithStdoutBashC("systemctl start firewalld")
-	if err != nil {
-		return fmt.Errorf("enable the firewall failed, err: %s", stdout)
+	if err := controller.HandleStart("firewalld"); err != nil {
+		return fmt.Errorf("enable the firewall failed, err: %v", err)
 	}
 	return nil
 }
 
 func (f *Firewall) Stop() error {
-	stdout, err := cmd.RunDefaultWithStdoutBashC("systemctl stop firewalld")
-	if err != nil {
-		return fmt.Errorf("stop the firewall failed, err: %s", stdout)
+	if err := controller.HandleStop("firewalld"); err != nil {
+		return fmt.Errorf("stop the firewall failed, err: %v", err)
 	}
 	return nil
 }
 
 func (f *Firewall) Restart() error {
-	stdout, err := cmd.RunDefaultWithStdoutBashC("systemctl restart firewalld")
-	if err != nil {
-		return fmt.Errorf("restart the firewall failed, err: %s", stdout)
+	if err := controller.HandleRestart("firewalld"); err != nil {
+		return fmt.Errorf("restart the firewall failed, err: %v", err)
 	}
 	return nil
 }
 
 func (f *Firewall) Reload() error {
-	stdout, err := cmd.RunDefaultWithStdoutBashC("firewall-cmd --reload")
-	if err != nil {
-		return fmt.Errorf("reload firewall failed, err: %s", stdout)
+	if err := cmd.RunDefaultBashC("firewall-cmd --reload"); err != nil {
+		return fmt.Errorf("reload firewall failed, err: %v", err)
 	}
 	return nil
 }
@@ -170,9 +167,8 @@ func (f *Firewall) Port(port FireInfo, operation string) error {
 		return buserr.New("ErrCmdIllegal")
 	}
 
-	stdout, err := cmd.RunDefaultWithStdoutBashCf("firewall-cmd --zone=public --%s-port=%s/%s --permanent", operation, port.Port, port.Protocol)
-	if err != nil {
-		return fmt.Errorf("%s (port: %s/%s strategy: %s) failed, err: %s", operation, port.Port, port.Protocol, port.Strategy, stdout)
+	if err := cmd.RunDefaultBashCf("firewall-cmd --zone=public --%s-port=%s/%s --permanent", operation, port.Port, port.Protocol); err != nil {
+		return fmt.Errorf("%s (port: %s/%s strategy: %s) failed, %v", operation, port.Port, port.Protocol, port.Strategy, err)
 	}
 	return nil
 }
@@ -195,14 +191,12 @@ func (f *Firewall) RichRules(rule FireInfo, operation string) error {
 		ruleStr += fmt.Sprintf("protocol=%s ", rule.Protocol)
 	}
 	ruleStr += rule.Strategy
-	stdout, err := cmd.RunDefaultWithStdoutBashCf("firewall-cmd --zone=public --%s-rich-rule '%s' --permanent", operation, ruleStr)
-	if err != nil {
-		return fmt.Errorf("%s rich rules (%s) failed, err: %s", operation, ruleStr, stdout)
+	if err := cmd.RunDefaultBashCf("firewall-cmd --zone=public --%s-rich-rule '%s' --permanent", operation, ruleStr); err != nil {
+		return fmt.Errorf("%s rich rules (%s) failed, %v", operation, ruleStr, err)
 	}
 	if len(rule.Address) == 0 {
-		stdout1, err := cmd.RunDefaultWithStdoutBashCf("firewall-cmd --zone=public --%s-rich-rule '%s' --permanent", operation, strings.ReplaceAll(ruleStr, "family=ipv4 ", "family=ipv6 "))
-		if err != nil {
-			return fmt.Errorf("%s rich rules (%s) failed, err: %s", operation, strings.ReplaceAll(ruleStr, "family=ipv4 ", "family=ipv6 "), stdout1)
+		if err := cmd.RunDefaultBashCf("firewall-cmd --zone=public --%s-rich-rule '%s' --permanent", operation, strings.ReplaceAll(ruleStr, "family=ipv4 ", "family=ipv6 ")); err != nil {
+			return fmt.Errorf("%s rich rules (%s) failed, %v", operation, strings.ReplaceAll(ruleStr, "family=ipv4 ", "family=ipv6 "), err)
 		}
 	}
 	return nil
@@ -214,11 +208,10 @@ func (f *Firewall) PortForward(info Forward, operation string) error {
 		ruleStr = fmt.Sprintf("firewall-cmd --zone=public --%s-forward-port=port=%s:proto=%s:toaddr=%s:toport=%s --permanent", operation, info.Port, info.Protocol, info.TargetIP, info.TargetPort)
 	}
 
-	stdout, err := cmd.RunDefaultWithStdoutBashC(ruleStr)
-	if err != nil {
-		return fmt.Errorf("%s port forward failed, err: %s", operation, stdout)
+	if err := cmd.RunDefaultBashC(ruleStr); err != nil {
+		return fmt.Errorf("%s port forward failed, %s", operation, err)
 	}
-	if err = f.Reload(); err != nil {
+	if err := f.Reload(); err != nil {
 		return err
 	}
 	return nil
@@ -250,13 +243,12 @@ func (f *Firewall) EnableForward() error {
 	stdout, err := cmd.RunDefaultWithStdoutBashC("firewall-cmd --zone=public --query-masquerade")
 	if err != nil {
 		if strings.HasSuffix(strings.TrimSpace(stdout), "no") {
-			stdout, err = cmd.RunDefaultWithStdoutBashC("firewall-cmd --zone=public --add-masquerade --permanent")
-			if err != nil {
-				return fmt.Errorf("%s: %s", err, stdout)
+			if err := cmd.RunDefaultBashC("firewall-cmd --zone=public --add-masquerade --permanent"); err != nil {
+				return err
 			}
 			return f.Reload()
 		}
-		return fmt.Errorf("%s: %s", err, stdout)
+		return err
 	}
 
 	return nil

agent/utils/firewall/client/iptables.go

@@ -39,37 +39,32 @@ func NewIptables() (*Iptables, error) {
 	return iptables, nil
 }
 
-func (iptables *Iptables) outf(tab, rule string, a ...any) (stdout string, err error) {
+func (iptables *Iptables) out(tab, rule string) (string, error) {
 	cmdMgr := cmd.NewCommandMgr(cmd.WithIgnoreExist1(), cmd.WithTimeout(20*time.Second))
-	stdout, err = cmdMgr.RunWithStdoutBashCf("%s iptables -t %s %s", iptables.CmdStr, tab, fmt.Sprintf(rule, a...))
-	if err != nil && stdout != "" {
-		global.LOG.Errorf("iptables failed, err: %s", stdout)
+	stdout, err := cmdMgr.RunWithStdoutBashCf("%s iptables -t %s %s", iptables.CmdStr, tab, rule)
+	if err != nil {
+		global.LOG.Errorf("iptables failed, %v", err)
 	}
-	return
+	return stdout, nil
 }
 
-func (iptables *Iptables) runf(tab, rule string, a ...any) error {
-	stdout, err := iptables.outf(tab, rule, a...)
-	if err != nil {
-		return fmt.Errorf("%s, %s", err, stdout)
+func (iptables *Iptables) run(tab, rule string) error {
+	if _, err := iptables.out(tab, rule); err != nil {
+		return err
 	}
-	if stdout != "" {
-		return fmt.Errorf("iptables error: %s", stdout)
-	}
-
 	return nil
 }
 
 func (iptables *Iptables) Check() error {
 	stdout, err := cmd.RunDefaultWithStdoutBashC("cat /proc/sys/net/ipv4/ip_forward")
 	if err != nil {
-		return fmt.Errorf("check ip_forward error: %w, output: %s", err, stdout)
+		return fmt.Errorf("check ip_forward failed, %v", err)
 	}
 	if strings.TrimSpace(stdout) == "0" {
 		return fmt.Errorf("ipv4 forward disabled")
 	}
 
-	chain, err := iptables.outf(NatTab, "-L -n | grep 'Chain %s'", PreRoutingChain)
+	chain, err := iptables.out(NatTab, fmt.Sprintf("-L -n | grep 'Chain %s'", PreRoutingChain))
 	if err != nil {
 		return fmt.Errorf("failed to check chain: %w", err)
 	}
@@ -81,18 +76,18 @@ func (iptables *Iptables) Check() error {
 }
 
 func (iptables *Iptables) NewChain(tab, chain string) error {
-	return iptables.runf(tab, "-N %s", chain)
+	return iptables.run(tab, "-N "+chain)
 }
 
 func (iptables *Iptables) AppendChain(tab string, chain, chain1 string) error {
-	return iptables.runf(tab, "-A %s -j %s", chain, chain1)
+	return iptables.run(tab, fmt.Sprintf("-A %s -j %s", chain, chain1))
 }
 
 func (iptables *Iptables) NatList(chain ...string) ([]IptablesNatInfo, error) {
 	if len(chain) == 0 {
 		chain = append(chain, PreRoutingChain)
 	}
-	stdout, err := iptables.outf(NatTab, "-nvL %s --line-numbers", chain[0])
+	stdout, err := iptables.out(NatTab, fmt.Sprintf("-nvL %s --line-numbers", chain[0]))
 	if err != nil {
 		return nil, err
 	}
@@ -132,11 +127,11 @@ func (iptables *Iptables) NatAdd(protocol, srcPort, dest, destPort, iface string
 			iptablesArg += fmt.Sprintf(" -i %s", iface)
 		}
 		iptablesArg += fmt.Sprintf(" -p %s --dport %s -j DNAT --to-destination %s:%s", protocol, srcPort, dest, destPort)
-		if err := iptables.runf(NatTab, iptablesArg); err != nil {
+		if err := iptables.run(NatTab, iptablesArg); err != nil {
 			return err
 		}
 
-		if err := iptables.runf(NatTab, fmt.Sprintf(
+		if err := iptables.run(NatTab, fmt.Sprintf(
 			"-A %s -d %s -p %s --dport %s -j MASQUERADE",
 			PostRoutingChain,
 			dest,
@@ -146,7 +141,7 @@ func (iptables *Iptables) NatAdd(protocol, srcPort, dest, destPort, iface string
 			return err
 		}
 
-		if err := iptables.runf(FilterTab, fmt.Sprintf(
+		if err := iptables.run(FilterTab, fmt.Sprintf(
 			"-A %s -d %s -p %s --dport %s -j ACCEPT",
 			ForwardChain,
 			dest,
@@ -156,7 +151,7 @@ func (iptables *Iptables) NatAdd(protocol, srcPort, dest, destPort, iface string
 			return err
 		}
 
-		if err := iptables.runf(FilterTab, fmt.Sprintf(
+		if err := iptables.run(FilterTab, fmt.Sprintf(
 			"-A %s -s %s -p %s --sport %s -j ACCEPT",
 			ForwardChain,
 			dest,
@@ -171,7 +166,7 @@ func (iptables *Iptables) NatAdd(protocol, srcPort, dest, destPort, iface string
 			iptablesArg += fmt.Sprintf(" -i %s", iface)
 		}
 		iptablesArg += fmt.Sprintf(" -p %s --dport %s -j REDIRECT --to-port %s", protocol, srcPort, destPort)
-		if err := iptables.runf(NatTab, iptablesArg); err != nil {
+		if err := iptables.run(NatTab, iptablesArg); err != nil {
 			return err
 		}
 	}
@@ -189,12 +184,12 @@ func (iptables *Iptables) NatAdd(protocol, srcPort, dest, destPort, iface string
 }
 
 func (iptables *Iptables) NatRemove(num string, protocol, srcPort, dest, destPort, iface string) error {
-	if err := iptables.runf(NatTab, "-D %s %s", PreRoutingChain, num); err != nil {
+	if err := iptables.run(NatTab, fmt.Sprintf("-D %s %s", PreRoutingChain, num)); err != nil {
 		return err
 	}
 
 	if dest != "" && dest != "127.0.0.1" && dest != "localhost" {
-		if err := iptables.runf(NatTab, fmt.Sprintf(
+		if err := iptables.run(NatTab, fmt.Sprintf(
 			"-D %s -d %s -p %s --dport %s -j MASQUERADE",
 			PostRoutingChain,
 			dest,
@@ -204,7 +199,7 @@ func (iptables *Iptables) NatRemove(num string, protocol, srcPort, dest, destPor
 			return err
 		}
 
-		if err := iptables.runf(FilterTab, fmt.Sprintf(
+		if err := iptables.run(FilterTab, fmt.Sprintf(
 			"-D %s -d %s -p %s --dport %s -j ACCEPT",
 			ForwardChain,
 			dest,
@@ -214,7 +209,7 @@ func (iptables *Iptables) NatRemove(num string, protocol, srcPort, dest, destPor
 			return err
 		}
 
-		if err := iptables.runf(FilterTab, fmt.Sprintf(
+		if err := iptables.run(FilterTab, fmt.Sprintf(
 			"-D %s -s %s -p %s --sport %s -j ACCEPT",
 			ForwardChain,
 			dest,
@@ -238,13 +233,13 @@ func (iptables *Iptables) NatRemove(num string, protocol, srcPort, dest, destPor
 }
 
 func (iptables *Iptables) Reload() error {
-	if err := iptables.runf(NatTab, "-F %s", PreRoutingChain); err != nil {
+	if err := iptables.run(NatTab, "-F "+PreRoutingChain); err != nil {
 		return err
 	}
-	if err := iptables.runf(NatTab, "-F %s", PostRoutingChain); err != nil {
+	if err := iptables.run(NatTab, "-F "+PostRoutingChain); err != nil {
 		return err
 	}
-	if err := iptables.runf(FilterTab, "-F %s", ForwardChain); err != nil {
+	if err := iptables.run(FilterTab, "-F "+ForwardChain); err != nil {
 		return err
 	}
 

agent/utils/firewall/client/ufw.go

@@ -38,24 +38,22 @@ func (f *Ufw) Status() (bool, error) {
 func (f *Ufw) Version() (string, error) {
 	stdout, err := cmd.RunDefaultWithStdoutBashCf("%s version | grep ufw", f.CmdStr)
 	if err != nil {
-		return "", fmt.Errorf("load the firewall status failed, err: %s", stdout)
+		return "", fmt.Errorf("load the firewall status failed, %v", err)
 	}
 	info := strings.ReplaceAll(stdout, "\n", "")
 	return strings.ReplaceAll(info, "ufw ", ""), nil
 }
 
 func (f *Ufw) Start() error {
-	stdout, err := cmd.RunDefaultWithStdoutBashCf("echo y | %s enable", f.CmdStr)
-	if err != nil {
-		return fmt.Errorf("enable the firewall failed, err: %s", stdout)
+	if err := cmd.RunDefaultBashCf("echo y | %s enable", f.CmdStr); err != nil {
+		return fmt.Errorf("enable the firewall failed, %v", err)
 	}
 	return nil
 }
 
 func (f *Ufw) Stop() error {
-	stdout, err := cmd.RunDefaultWithStdoutBashCf("%s disable", f.CmdStr)
-	if err != nil {
-		return fmt.Errorf("stop the firewall failed, err: %s", stdout)
+	if err := cmd.RunDefaultBashCf("%s disable", f.CmdStr); err != nil {
+		return fmt.Errorf("stop the firewall failed, %v", err)
 	}
 	return nil
 }
@@ -184,9 +182,8 @@ func (f *Ufw) Port(port FireInfo, operation string) error {
 	if len(port.Protocol) != 0 {
 		command += fmt.Sprintf("/%s", port.Protocol)
 	}
-	stdout, err := cmd.RunDefaultWithStdoutBashC(command)
-	if err != nil {
-		return fmt.Errorf("%s (%s) failed, err: %s", operation, command, stdout)
+	if err := cmd.RunDefaultBashC(command); err != nil {
+		return fmt.Errorf("%s (%s) failed, %v", operation, command, err)
 	}
 	return nil
 }
@@ -224,13 +221,12 @@ func (f *Ufw) RichRules(rule FireInfo, operation string) error {
 	stdout, err := cmd.RunDefaultWithStdoutBashC(ruleStr)
 	if err != nil {
 		if strings.Contains(stdout, "ERROR: Invalid position") || strings.Contains(stdout, "ERROR: 无效位置") {
-			stdout, err := cmd.RunDefaultWithStdoutBashC(strings.ReplaceAll(ruleStr, "insert 1 ", ""))
-			if err != nil {
-				return fmt.Errorf("%s rich rules (%s), failed, err: %s", operation, ruleStr, stdout)
+			if err := cmd.RunDefaultBashC(strings.ReplaceAll(ruleStr, "insert 1 ", "")); err != nil {
+				return fmt.Errorf("%s rich rules (%s), failed, %v", operation, ruleStr, err)
 			}
 			return nil
 		}
-		return fmt.Errorf("%s rich rules (%s), failed, err: %s", operation, ruleStr, stdout)
+		return fmt.Errorf("%s rich rules (%s), failed, %v", operation, ruleStr, err)
 	}
 	return nil
 }

agent/utils/ntp/ntp.go

@@ -62,9 +62,8 @@ func GetRemoteTime(site string) (time.Time, error) {
 func UpdateSystemTime(dateTime string) error {
 	system := runtime.GOOS
 	if system == "linux" {
-		stdout2, err := cmd.RunDefaultWithStdoutBashCf(`%s date -s "%s"`, cmd.SudoHandleCmd(), dateTime)
-		if err != nil {
-			return fmt.Errorf("update system time failed,stdout: %s, err: %v", stdout2, err)
+		if err := cmd.RunDefaultBashCf(`%s date -s "%s"`, cmd.SudoHandleCmd(), dateTime); err != nil {
+			return fmt.Errorf("update system time failed, %v", err)
 		}
 		return nil
 	}
@@ -74,9 +73,8 @@ func UpdateSystemTime(dateTime string) error {
 func UpdateSystemTimeZone(timezone string) error {
 	system := runtime.GOOS
 	if system == "linux" {
-		stdout, err := cmd.RunDefaultWithStdoutBashCf(`%s timedatectl set-timezone "%s"`, cmd.SudoHandleCmd(), timezone)
-		if err != nil {
-			return fmt.Errorf("update system time zone failed, stdout: %s, err: %v", stdout, err)
+		if err := cmd.RunDefaultBashCf(`%s timedatectl set-timezone "%s"`, cmd.SudoHandleCmd(), timezone); err != nil {
+			return fmt.Errorf("update system time zone failed, %v", err)
 		}
 		return nil
 	}

agent/utils/systemctl/systemctl.go

@@ -1,116 +0,0 @@
-package systemctl
-
-import (
-	"bytes"
-	"fmt"
-	"github.com/pkg/errors"
-	"os/exec"
-	"strings"
-)
-
-func RunSystemCtl(args ...string) (string, error) {
-	cmd := exec.Command("systemctl", args...)
-	output, err := cmd.CombinedOutput()
-	if err != nil {
-		return string(output), fmt.Errorf("failed to run command: %w", err)
-	}
-	return string(output), nil
-}
-
-func isSnapService(serviceName string) bool {
-	cmd := exec.Command("snap", "services")
-	var out bytes.Buffer
-	cmd.Stdout = &out
-	if err := cmd.Run(); err != nil {
-		return false
-	}
-	return strings.Contains(out.String(), serviceName)
-}
-
-func isSnapServiceActive(serviceName string) bool {
-	cmd := exec.Command("snap", "services")
-	var out bytes.Buffer
-	cmd.Stdout = &out
-	if err := cmd.Run(); err != nil {
-		return false
-	}
-	lines := strings.Split(out.String(), "\n")
-	for _, line := range lines {
-		if strings.Contains(line, serviceName) && strings.Contains(line, "active") {
-			return true
-		}
-	}
-	return false
-}
-
-func IsActive(serviceName string) (bool, error) {
-	out, err := RunSystemCtl("is-active", serviceName)
-	if err == nil {
-		return strings.TrimSpace(out) == "active", nil
-	}
-
-	if isSnapServiceActive(serviceName) {
-		return true, nil
-	}
-	return false, fmt.Errorf("service %s is not active: %v", serviceName, err)
-}
-
-func IsEnable(serviceName string) (bool, error) {
-	out, err := RunSystemCtl("is-enabled", serviceName)
-	if err == nil {
-		return strings.TrimSpace(out) == "enabled", nil
-	}
-
-	if isSnapServiceActive(serviceName) {
-		return true, nil
-	}
-	return false, fmt.Errorf("failed to determine if service %s is enabled: %v", serviceName, err)
-}
-
-func IsExist(serviceName string) (bool, error) {
-	out, err := RunSystemCtl("is-enabled", serviceName)
-	if err == nil || strings.Contains(out, "disabled") {
-		return true, nil
-	}
-	if isSnapService(serviceName) {
-		return true, nil
-	}
-	return false, nil
-}
-
-func handlerErr(out string, err error) error {
-	if err != nil {
-		if out != "" {
-			return errors.New(out)
-		}
-		return err
-	}
-	return nil
-}
-
-func Restart(serviceName string) error {
-	out, err := RunSystemCtl("restart", serviceName)
-	if err == nil {
-		return nil
-	}
-	if isSnapService(serviceName) {
-		cmd := exec.Command("snap", "restart", serviceName)
-		output, snapErr := cmd.CombinedOutput()
-		return handlerErr(string(output), snapErr)
-	}
-	return handlerErr(out, err)
-}
-
-func Operate(operate, serviceName string) error {
-	out, err := RunSystemCtl(operate, serviceName)
-	if err == nil {
-		return nil
-	}
-
-	if isSnapService(serviceName) && (operate == "start" || operate == "stop" || operate == "restart") {
-		cmd := exec.Command("snap", operate, serviceName)
-		output, snapErr := cmd.CombinedOutput()
-		return handlerErr(string(output), snapErr)
-	}
-	return handlerErr(out, err)
-}

agent/utils/toolbox/fail2ban.go

@@ -8,7 +8,7 @@ import (
 
 	"github.com/1Panel-dev/1Panel/agent/global"
 	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
-	"github.com/1Panel-dev/1Panel/agent/utils/systemctl"
+	"github.com/1Panel-dev/1Panel/agent/utils/controller"
 )
 
 type Fail2ban struct{}
@@ -23,15 +23,14 @@ type FirewallClient interface {
 }
 
 func NewFail2Ban() (*Fail2ban, error) {
-	isExist, _ := systemctl.IsExist("fail2ban.service")
+	isExist, _ := controller.CheckExist("fail2ban.service")
 	if isExist {
 		if _, err := os.Stat(defaultPath); err != nil {
 			if err := initLocalFile(); err != nil {
 				return nil, err
 			}
-			stdout, err := cmd.RunDefaultWithStdoutBashC("systemctl restart fail2ban.service")
-			if err != nil {
-				global.LOG.Errorf("restart fail2ban failed, err: %s", stdout)
+			if err := controller.HandleRestart("fail2ban.service"); err != nil {
+				global.LOG.Errorf("restart fail2ban failed, err: %v", err)
 				return nil, err
 			}
 		}
@@ -40,9 +39,9 @@ func NewFail2Ban() (*Fail2ban, error) {
 }
 
 func (f *Fail2ban) Status() (bool, bool, bool) {
-	isEnable, _ := systemctl.IsEnable("fail2ban.service")
-	isActive, _ := systemctl.IsActive("fail2ban.service")
-	isExist, _ := systemctl.IsExist("fail2ban.service")
+	isEnable, _ := controller.CheckEnable("fail2ban.service")
+	isActive, _ := controller.CheckActive("fail2ban.service")
+	isExist, _ := controller.CheckExist("fail2ban.service")
 
 	return isEnable, isActive, isExist
 }
@@ -50,7 +49,7 @@ func (f *Fail2ban) Status() (bool, bool, bool) {
 func (f *Fail2ban) Version() string {
 	stdout, err := cmd.RunDefaultWithStdoutBashC("fail2ban-client version")
 	if err != nil {
-		global.LOG.Errorf("load the fail2ban version failed, err: %s", stdout)
+		global.LOG.Errorf("load the fail2ban version failed, %v", err)
 		return "-"
 	}
 	return strings.ReplaceAll(stdout, "\n", "")
@@ -59,15 +58,13 @@ func (f *Fail2ban) Version() string {
 func (f *Fail2ban) Operate(operate string) error {
 	switch operate {
 	case "start", "restart", "stop", "enable", "disable":
-		stdout, err := cmd.RunDefaultWithStdoutBashCf("systemctl %s fail2ban.service", operate)
-		if err != nil {
-			return fmt.Errorf("%s the fail2ban.service failed, err: %s", operate, stdout)
+		if err := controller.Handle(operate, "fail2ban.service"); err != nil {
+			return fmt.Errorf("%s the fail2ban.service failed, err: %v", operate, err)
 		}
 		return nil
 	case "reload":
-		stdout, err := cmd.RunDefaultWithStdoutBashC("fail2ban-client reload")
-		if err != nil {
-			return fmt.Errorf("fail2ban-client reload, err: %s", stdout)
+		if err := cmd.RunDefaultBashC("fail2ban-client reload"); err != nil {
+			return fmt.Errorf("fail2ban-client reload, %v", err)
 		}
 		return nil
 	default:
@@ -159,9 +156,9 @@ action = %(action_mwl)s
 logpath = $logpath`
 
 	banaction := ""
-	if active, _ := systemctl.IsActive("firewalld"); active {
+	if active, _ := controller.CheckActive("firewalld"); active {
 		banaction = "firewallcmd-ipset"
-	} else if active, _ := systemctl.IsActive("ufw"); active {
+	} else if active, _ := controller.CheckActive("ufw"); active {
 		banaction = "ufw"
 	} else {
 		banaction = "iptables-allports"

agent/utils/toolbox/pure-ftpd.go

@@ -2,7 +2,6 @@ package toolbox
 
 import (
 	"bufio"
-	"errors"
 	"fmt"
 	"os"
 	"os/user"
@@ -13,7 +12,7 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/constant"
 	"github.com/1Panel-dev/1Panel/agent/global"
 	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
-	"github.com/1Panel-dev/1Panel/agent/utils/systemctl"
+	"github.com/1Panel-dev/1Panel/agent/utils/controller"
 	"github.com/1Panel-dev/1Panel/agent/utils/toolbox/helper"
 )
 
@@ -63,29 +62,26 @@ func NewFtpClient() (*Ftp, error) {
 
 	groupItem, err := user.LookupGroupId("1000")
 	if err == nil {
-		stdout2, err := cmd.RunDefaultWithStdoutBashCf("useradd -u 1000 -g %s %s", groupItem.Name, "1panel")
-		if err != nil {
-			return nil, errors.New(stdout2)
+		if err := cmd.RunDefaultBashCf("useradd -u 1000 -g %s %s", groupItem.Name, "1panel"); err != nil {
+			return nil, err
 		}
 		return &Ftp{DefaultUser: "1panel", DefaultGroup: groupItem.Name}, nil
 	}
 	if err.Error() != user.UnknownGroupIdError("1000").Error() {
 		return nil, err
 	}
-	stdout, err := cmd.RunDefaultWithStdoutBashC("groupadd -g 1000 1panel")
-	if err != nil {
-		return nil, errors.New(string(stdout))
+	if err := cmd.RunDefaultBashC("groupadd -g 1000 1panel"); err != nil {
+		return nil, err
 	}
-	stdout2, err := cmd.RunDefaultWithStdoutBashC("useradd -u 1000 -g 1panel 1panel")
-	if err != nil {
-		return nil, errors.New(stdout2)
+	if err := cmd.RunDefaultBashC("useradd -u 1000 -g 1panel 1panel"); err != nil {
+		return nil, err
 	}
 	return &Ftp{DefaultUser: "1panel", DefaultGroup: "1panel"}, nil
 }
 
 func (f *Ftp) Status() (bool, bool) {
-	isActive, _ := systemctl.IsActive("pure-ftpd.service")
-	isExist, _ := systemctl.IsExist("pure-ftpd.service")
+	isActive, _ := controller.CheckActive("pure-ftpd.service")
+	isExist, _ := controller.CheckExist("pure-ftpd.service")
 
 	return isActive, isExist
 }
@@ -93,9 +89,8 @@ func (f *Ftp) Status() (bool, bool) {
 func (f *Ftp) Operate(operate string) error {
 	switch operate {
 	case "start", "restart", "stop":
-		stdout, err := cmd.RunDefaultWithStdoutBashCf("systemctl %s pure-ftpd.service", operate)
-		if err != nil {
-			return fmt.Errorf("%s the pure-ftpd.service failed, err: %s", operate, stdout)
+		if err := controller.Handle(operate, "pure-ftpd.service"); err != nil {
+			return fmt.Errorf("%s the pure-ftpd.service failed, err: %v", operate, err)
 		}
 		return nil
 	default:
@@ -119,17 +114,15 @@ func (f *Ftp) UserAdd(username, passwd, path string) error {
 		return err
 	}
 	_ = f.Reload()
-	std2, err := cmd.RunDefaultWithStdoutBashCf("chown -R %s:%s %s", f.DefaultUser, f.DefaultGroup, path)
-	if err != nil {
-		return errors.New(std2)
+	if err := cmd.RunDefaultBashCf("chown -R %s:%s %s", f.DefaultUser, f.DefaultGroup, path); err != nil {
+		return err
 	}
 	return nil
 }
 
 func (f *Ftp) UserDel(username string) error {
-	std, err := cmd.RunDefaultWithStdoutBashCf("pure-pw userdel %s", username)
-	if err != nil {
-		return errors.New(std)
+	if err := cmd.RunDefaultBashCf("pure-pw userdel %s", username); err != nil {
+		return err
 	}
 	_ = f.Reload()
 	return nil
@@ -186,13 +179,11 @@ func (f *Ftp) SetPasswd(username, passwd string) error {
 }
 
 func (f *Ftp) SetPath(username, path string) error {
-	std, err := cmd.RunDefaultWithStdoutBashCf("pure-pw usermod %s -d %s", username, path)
-	if err != nil {
-		return errors.New(std)
+	if err := cmd.RunDefaultBashCf("pure-pw usermod %s -d %s", username, path); err != nil {
+		return err
 	}
-	std2, err := cmd.RunDefaultWithStdoutBashCf("chown -R %s:%s %s", f.DefaultUser, f.DefaultGroup, path)
-	if err != nil {
-		return errors.New(std2)
+	if err := cmd.RunDefaultBashCf("chown -R %s:%s %s", f.DefaultUser, f.DefaultGroup, path); err != nil {
+		return err
 	}
 	return nil
 }
@@ -202,9 +193,8 @@ func (f *Ftp) SetStatus(username, status string) error {
 	if status == constant.StatusDisable {
 		statusItem = "1"
 	}
-	std, err := cmd.RunDefaultWithStdoutBashCf("pure-pw usermod %s -r %s", username, statusItem)
-	if err != nil {
-		return errors.New(std)
+	if err := cmd.RunDefaultBashCf("pure-pw usermod %s -r %s", username, statusItem); err != nil {
+		return err
 	}
 	return nil
 }
@@ -212,7 +202,7 @@ func (f *Ftp) SetStatus(username, status string) error {
 func (f *Ftp) LoadList() ([]FtpList, error) {
 	std, err := cmd.RunDefaultWithStdoutBashC("pure-pw list")
 	if err != nil {
-		return nil, errors.New(std)
+		return nil, err
 	}
 	var lists []FtpList
 	lines := strings.Split(std, "\n")
@@ -223,7 +213,7 @@ func (f *Ftp) LoadList() ([]FtpList, error) {
 		}
 		std2, err := cmd.RunDefaultWithStdoutBashCf("pure-pw  show %s | grep 'Allowed client IPs :'", parts[0])
 		if err != nil {
-			global.LOG.Errorf("handle pure-pw show %s failed, err: %v", parts[0], std2)
+			global.LOG.Errorf("handle pure-pw show %s failed, %v", parts[0], err)
 			continue
 		}
 		status := constant.StatusDisable
@@ -237,9 +227,8 @@ func (f *Ftp) LoadList() ([]FtpList, error) {
 }
 
 func (f *Ftp) Reload() error {
-	std, err := cmd.RunDefaultWithStdoutBashC("pure-pw mkdb")
-	if err != nil {
-		return errors.New(std)
+	if err := cmd.RunDefaultBashC("pure-pw mkdb"); err != nil {
+		return err
 	}
 	return nil
 }
@@ -296,7 +285,7 @@ func (f *Ftp) LoadLogs(user, operation string) ([]FtpLog, error) {
 }
 
 func handleGunzip(path string) error {
-	if _, err := cmd.RunDefaultWithStdoutBashCf("gunzip %s", path); err != nil {
+	if err := cmd.RunDefaultBashCf("gunzip %s", path); err != nil {
 		return err
 	}
 	return nil