update ynSwagger,sync to master

liuxiaolong

2019-11-13 f26a0cab5bca17b7eab57f6330e576271e17a17f

 extend/sys/system.go

@@ -1 +1,236 @@
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/sh", "-c", cmdStr).Output()
}

// 检查 root权限
func CheckRootPermissions() bool {
   showRootCMD := exec.Command("/bin/sh", "-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\" | 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/bin/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
}