package sys
|
|
import (
|
"errors"
|
"os"
|
"os/exec"
|
"strconv"
|
"webserver/extend/config"
|
"webserver/extend/util"
|
|
"fmt"
|
"net"
|
"strings"
|
"time"
|
)
|
|
func execRootCommand(cmd string) ([]byte, error) {
|
pwd := config.Server.SudoPassword
|
cmdStr := fmt.Sprintf("echo %s | sudo -S %s", pwd, cmd)
|
|
return exec.Command("/bin/bash", "-c", cmdStr).Output()
|
}
|
|
// 检查 root权限
|
func CheckRootPermissions() bool {
|
showRootCMD := exec.Command("/bin/bash", "-c", "ls /root/")
|
if _, err := showRootCMD.Output(); err != nil {
|
return false
|
}
|
|
return true
|
}
|
|
// 获取本机网卡IP
|
func GetLocalIP(networkName string) (ipv4 string, mask string, err error) {
|
interfaces, err := net.Interfaces()
|
if err != nil {
|
return "", "", err
|
}
|
|
for _, i := range interfaces {
|
byName, err := net.InterfaceByName(i.Name)
|
if err != nil {
|
return "", "", err
|
}
|
addresses, err := byName.Addrs()
|
for _, v := range addresses {
|
if ipnet, ok := v.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
|
if ipnet.IP.To4() != nil {
|
if byName.Name == networkName {
|
maskStr := ipnet.Mask.String()
|
mask64, _ := strconv.ParseUint(maskStr, 16, 32)
|
return ipnet.IP.String(), util.IpIntToString(int(mask64)), nil
|
}
|
}
|
}
|
}
|
}
|
return "", "", errors.New("ipv4 not found")
|
}
|
|
// 获取本机网关ip
|
func GetDefaultRoute(networkName string) (route string, err error) {
|
cmdStr := fmt.Sprintf("ip route show | grep -P \"^default.*%s onlink\" | awk '{printf $3}'", networkName)
|
cmd := exec.Command("/bin/sh", "-c", cmdStr)
|
b, err := cmd.Output()
|
if err != nil {
|
return "", err
|
}
|
|
return string(b), nil
|
}
|
|
func GetDnsServer() (dns string, err error) {
|
cmd := exec.Command("/bin/sh", "-c", "cat /etc/resolv.conf | grep nameserver | head -1 |awk '{printf $2}'")
|
b, err := cmd.Output()
|
if err != nil {
|
return "", err
|
}
|
|
return string(b), nil
|
}
|
|
// 配置服务器网络
|
func SetNetworkConfig(ipv4, netmask, gateway, dns string) (bool, string) {
|
networkConfigScript := "/opt/vasystem/script/netconfig"
|
ifname := config.Server.NetworkAdapter
|
localIPv4, localNetMask, _ := GetLocalIP(ifname)
|
localGW, _ := GetDefaultRoute(ifname)
|
localDNS, _ := GetDnsServer()
|
|
if localIPv4 == ipv4 && localNetMask == netmask && localGW == gateway && localDNS == dns {
|
return true, ""
|
}
|
|
// 检查文件是否存在
|
if _, err := os.Stat(networkConfigScript); err != nil {
|
return false, "network Config Script not exist"
|
}
|
// # netconfig enp59s0f0 192.168.1.2 255.255.255.0 192.168.1.1 192.168.100.1
|
cmdStr := fmt.Sprintf("%s %s %s %s %s %s", networkConfigScript, ifname, ipv4, netmask, gateway, dns)
|
stdout, err := execRootCommand(cmdStr)
|
|
return err == nil, string(stdout)
|
}
|
|
// 配置时区
|
func TimeZone() (string, int64) {
|
cmd := exec.Command("/bin/sh", "-c", "echo -n $TZ")
|
tz, _ := cmd.Output()
|
if tzstr := string(tz); tzstr != "" {
|
return tzstr, time.Now().Unix()
|
}
|
|
zone, _ := time.Now().Zone()
|
return zone, time.Now().Unix()
|
}
|
|
func NTPConfig() (bool, string, string) {
|
status, server, interval := false, "", ""
|
|
cron, _ := execRootCommand("crontab -l | grep ntpdate | tr -d '\n'")
|
if task := string(cron); task != "" {
|
status = true
|
slice := strings.Split(task, " ")
|
interval, server = slice[0][2:], slice[len(slice)-1]
|
}
|
|
return status, server, interval
|
}
|
|
// 设置时区
|
func SetTimeZone(tz string) bool {
|
if _, err := time.LoadLocation(tz); err != nil {
|
return false
|
}
|
|
// set env
|
envCMD := exec.Command("/bin/sh", "-c", "TZ=%s", tz)
|
envCMD.Run()
|
// change permanent to the file '.profile'
|
|
cleanTZ := exec.Command("/bin/sh", "-c", "sed -i '/^TZ=.*$/d' ~/.profile")
|
cleanTZ.Run()
|
|
TZ := "TZ='" + tz + "'; export TZ"
|
appendTZCMD := fmt.Sprintf("echo \"%s\" >> ~/.profile;", TZ)
|
appendTZ := exec.Command("/bin/sh", "-c", appendTZCMD)
|
appendTZ.Run()
|
|
return true
|
}
|
|
// 配置系统时间
|
func SetLocalTime(newTime string) bool {
|
const TimeLayout = "2006-01-02 15:04:05"
|
_, err := time.Parse(TimeLayout, newTime)
|
if err != nil {
|
return false
|
}
|
|
dateCMD := fmt.Sprintf("date -s \"%s\"", newTime)
|
execRootCommand(dateCMD)
|
stopNTPCron()
|
|
return true
|
}
|
|
const NTPCRONTABFILE = "/tmp/.webServer.crontab"
|
|
func EnableNTPCron(server string, interval int) bool {
|
stopNTPCron()
|
|
if ip := net.ParseIP(server); ip == nil {
|
return false
|
}
|
|
update := fmt.Sprintf("echo \"*/%d * * * * /usr/sbin/ntpdate %s\" >> %s", interval, server, NTPCRONTABFILE)
|
execRootCommand(update)
|
|
addNTPTask := fmt.Sprintf("crontab %s", NTPCRONTABFILE)
|
execRootCommand(addNTPTask)
|
|
return true
|
}
|
|
func stopNTPCron() {
|
update := fmt.Sprintf("crontab -l | grep -v /usr/sbin/ntpdate > %s", NTPCRONTABFILE)
|
execRootCommand(update)
|
|
cleanNTPTask := fmt.Sprintf("crontab %s", NTPCRONTABFILE)
|
execRootCommand(cleanNTPTask)
|
}
|
|
func RunNTPDate(server string) bool {
|
if ip := net.ParseIP(server); ip == nil {
|
return false
|
}
|
|
ntpdate := fmt.Sprintf("/usr/sbin/ntpdate %s", server)
|
_, err := execRootCommand(ntpdate)
|
|
return err == nil
|
}
|
|
func Reboot() (bool, string) {
|
stdout, err := execRootCommand("reboot")
|
|
return err == nil, string(stdout)
|
}
|
|
// * * * * * /bin/echo "$(date) Perform basic-reboot-task" >> /tmp/webserver.crontab.log;/sbin/reboot & >> /tmp/webserver.crontab.log
|
func ReadRebootTaskInCrontab() (bool, string) {
|
stdout, err := execRootCommand("crontab -l | grep basic-reboot-task | sed -z -r 's/([^0-9* ]+)(.+)//g'")
|
return err == nil, string(stdout)
|
}
|
|
func CleanRebootTask() {
|
update := fmt.Sprintf("crontab -l | grep -v basic-reboot-task > %s", NTPCRONTABFILE)
|
execRootCommand(update)
|
|
crontab := fmt.Sprintf("crontab %s", NTPCRONTABFILE)
|
execRootCommand(crontab)
|
}
|
|
func UpdateRebootTask(task string) bool {
|
CleanRebootTask()
|
|
tasks := fmt.Sprintf("%s /bin/echo \"$(date) Perform basic-reboot-task\" >> /tmp/webserver.crontab.log;/sbin/reboot & >> /tmp/webserver.crontab.log", task)
|
update := fmt.Sprintf("echo '%s' >> %s", tasks, NTPCRONTABFILE)
|
execRootCommand(update)
|
addNTPTask := fmt.Sprintf("crontab %s", NTPCRONTABFILE)
|
_, err := execRootCommand(addNTPTask)
|
|
return err == nil
|
}
|
|
const ngConfig = "/opt/vasystem/config/system-2.0.conf"
|
func GetNginxListenPort() string {
|
_, err := os.Stat(ngConfig)
|
if err != nil {
|
return "7003"
|
}
|
|
cmdStr := fmt.Sprintf("cat %s | grep listen | awk '{printf $2}' | sed 's/;//g'", ngConfig)
|
cmd := exec.Command("/bin/sh", "-c", cmdStr)
|
port, err := cmd.Output()
|
if err != nil {
|
return ""
|
}
|
|
return string(port)
|
}
|
|
func SetNginxListenPort(port string) bool {
|
_, err := os.Stat(ngConfig)
|
if err != nil {
|
return false
|
}
|
|
// 修改配置文件端口
|
cmdStr := fmt.Sprintf("sed -i 's/listen.*/listen %s;/' %s", port, ngConfig)
|
cmd := exec.Command("/bin/sh", "-c", cmdStr)
|
_, err = cmd.Output()
|
if err != nil {
|
return false
|
}
|
|
// 重启nginx
|
_, err = execRootCommand("service nginx reload")
|
|
return err == nil
|
}
|
