package sys
|
|
import (
|
"basic.com/valib/bhomedbapi.git"
|
"basic.com/valib/logger.git"
|
"errors"
|
"github.com/satori/go.uuid"
|
"os"
|
"os/exec"
|
"regexp"
|
"strconv"
|
"vamicro/config"
|
"vamicro/extend/util"
|
"vamicro/system-service/models"
|
sysVo "vamicro/system-service/vo"
|
|
"fmt"
|
"net"
|
"strings"
|
"time"
|
)
|
|
func execRootCommand(cmd string) ([]byte, error) {
|
pwd := config.Server.SudoPassword
|
cmdStr := fmt.Sprintf("echo %s | sudo -S %s", pwd, cmd)
|
logger.Debug("root run:" + 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尚未设置")
|
}
|
|
// 获取本机网关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 | grep -v '#' | 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, ifname string) (bool, string) {
|
networkConfigScript := "/opt/vasystem/script/netconfig"
|
//ifname := config.Server.NetworkAdapter
|
localIPv4, localNetMask, err := GetLocalIP(ifname)
|
if err != nil {
|
//return false, err.Error()
|
}
|
localGW, err := GetDefaultRoute(ifname)
|
if err != nil {
|
return false, err.Error()
|
}
|
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)
|
if nil == err {
|
return true, string(stdout)
|
}
|
|
return false, err.Error() + ":" + string(stdout) + "some wrong happens"
|
}
|
|
// GetNetWorkInfo 获取网卡配置信息
|
func GetNetWorkInfo(ifname string) (map[string]string, error) {
|
var localIPv4, localNetMask, localGW, localDNS string
|
var err error
|
|
// 网卡未配置ip的情况下, 其他信息也需要显示为空.
|
localIPv4, localNetMask, err = GetLocalIP(ifname)
|
if err == nil {
|
localGW, err = GetDefaultRoute(ifname)
|
localDNS, err = GetDnsServer()
|
}
|
|
info := make(map[string]string, 0)
|
info["ifname"] = ifname
|
info["ip"] = localIPv4
|
info["subMask"] = localNetMask
|
info["gateway"] = localGW
|
info["dns"] = localDNS
|
|
return info, err
|
}
|
|
//获取网卡信息
|
func GetNetWorkCards() ([]sysVo.NetWorkCard, error) {
|
interfaces, err := net.Interfaces()
|
if nil != err {
|
return nil, err
|
}
|
//获取无线网卡
|
iwDevMap := make(map[string]string, 0)
|
iwDevs, err := GetIwDev()
|
if nil == err {
|
for _, item := range iwDevs {
|
iwDevMap[item] = item
|
}
|
}
|
//获取网卡LOWER_UP状态
|
lowerUpState := ""
|
content, err := execRootCommand("ip addr show|grep LOWER_UP")
|
if nil == err {
|
lowerUpState = string(content)
|
}
|
l := len(interfaces)
|
var data = make([]sysVo.NetWorkCard, 0, l)
|
for _, interface1 := range interfaces {
|
if strings.Contains(interface1.Flags.String(), "loopback") {
|
continue
|
}
|
_, ok := iwDevMap[interface1.Name]
|
lowerUp := strings.Contains(lowerUpState, interface1.Name)
|
Addrs, _ := interface1.Addrs()
|
data = append(data, sysVo.NetWorkCard{
|
Name: interface1.Name,
|
Index: interface1.Index,
|
MTU: interface1.MTU,
|
Flags: interface1.Flags.String(),
|
WireLess: ok,
|
LowerUp: lowerUp,
|
Addrs: Addrs,
|
})
|
}
|
|
return data, nil
|
}
|
|
//修改IP发布消息
|
func IpChangePublish(newIp string) bool {
|
//修改国标ip
|
tmpResourceConf := models.ResourceConfig{}
|
rcErr := tmpResourceConf.Select()
|
|
var gbApi bhomedbapi.Gb28181Api
|
flag, gbConf := gbApi.Show()
|
|
if flag { //国标已配置
|
setGbIp := ""
|
if rcErr == nil { //对外服务已配置
|
if tmpResourceConf.IpType == models.IpType_Local { //配置的是本机Ip
|
setGbIp = newIp
|
} else { //设置的是对外服务，则不需要刷新了
|
|
}
|
} else { //对外服务ip未配置,国标使用本机ip
|
setGbIp = newIp
|
}
|
if setGbIp != "" && setGbIp != gbConf.ServerIp {
|
gbConf.ServerIp = setGbIp
|
paramBody := util.Struct2Map(gbConf)
|
return gbApi.Edit(paramBody)
|
}
|
}
|
return false
|
}
|
|
/**
|
更新配置
|
@param serverName 服务名称
|
@param newIp 服务Ip
|
@return bool 是否是新创建的配置
|
@return error 错误信息
|
*/
|
func ConfigUpdate(serverName, newIp string) (bool, error) {
|
if "" == serverName && "" == newIp {
|
return false, errors.New("参数错误")
|
}
|
conf := new(models.LocalConfig)
|
logger.Debug("saveServerInfo serverName:", serverName)
|
if err := conf.Select(); err != nil { // 查询是否存在
|
logger.Debug("saveServerInfo err:", err)
|
return false, err
|
} else { // 存在及修改 不存在 即添加
|
if "" != serverName {
|
conf.ServerName = serverName
|
}
|
conf.ServerId = config.Server.AnalyServerId
|
logger.Debug("saveServerInfo newIp:", newIp)
|
if newIp != "" && (conf.AlarmIp != newIp || conf.WebPicIp != newIp) {
|
conf.AlarmIp = newIp
|
conf.WebPicIp = newIp
|
}
|
if conf.ServerId == "" {
|
conf.ServerId = uuid.NewV4().String()
|
if conf.AlarmPort == 0 {
|
conf.AlarmPort = 9200
|
}
|
if conf.WebPicPort == 0 {
|
conf.WebPicPort = 6333
|
}
|
if conf.ServerName == "" {
|
conf.ServerName = newIp
|
}
|
if "" == newIp {
|
newIp, _, e := util.GetLocalIP(config.Server.NetworkAdapter)
|
if nil != e {
|
return false, e
|
}
|
conf.AlarmIp = newIp
|
conf.WebPicIp = newIp
|
}
|
if err := conf.Insert(); err != nil {
|
return false, err
|
} else {
|
return true, nil
|
}
|
} else {
|
if e := conf.Update(); e != nil {
|
return false, e
|
} else {
|
if "" != newIp {
|
go func() {
|
//网卡可能在重启
|
time.Sleep(20 * time.Second)
|
//修改国标ip
|
IpChangePublish(newIp)
|
}()
|
}
|
|
return false, nil
|
}
|
}
|
}
|
}
|
|
// 配置时区
|
func TimeZone() (string, int64) {
|
//cmd := exec.Command("/bin/sh", "-c", "echo -n $TZ")
|
//tz, _ := cmd.Output()
|
tz, _ := execRootCommand("readlink /etc/localtime")
|
tzstr := string(tz)
|
reg, err := regexp.Compile(`.*/zoneinfo/`)
|
if err == nil {
|
tzstr = reg.ReplaceAllString(tzstr, "")
|
tzstr = strings.TrimSpace(tzstr)
|
}
|
if tzstr != "" {
|
return strings.TrimSpace(tzstr), time.Now().Unix()
|
} else {
|
return "", 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()
|
execRootCommand(fmt.Sprintf("ln -sf /usr/share/zoneinfo/%s /etc/localtime", tz))
|
|
return true
|
}
|
|
// 配置系统时间
|
func SetLocalTime(newTime string, tz string) bool {
|
const TimeLayout = "2006-01-02 15:04:05"
|
_, err := time.Parse(TimeLayout, newTime)
|
if err != nil {
|
return false
|
}
|
if "" == tz {
|
tz, _ = TimeZone()
|
}
|
|
dateCMD := fmt.Sprintf("date -s \"`date \"%s\" --date='TZ=\"%s\" %s'`\"", "+%Y-%m-%d %H:%M:%S", tz, 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 = "/usr/local/openresty/nginx/conf/conf.d/smart-ai.conf"
|
|
func GetNginxListenPort() string {
|
_, err := os.Stat(ngConfig)
|
if err != nil {
|
return ""
|
}
|
|
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 GetNginxListenHost() string {
|
_, err := os.Stat(ngConfig)
|
if err != nil {
|
return ""
|
}
|
cmdStr := fmt.Sprintf("cat %s | grep server_name | awk '{printf $2}' | sed 's/;//g'", ngConfig)
|
cmd := exec.Command("/bin/sh", "-c", cmdStr)
|
host, err := cmd.Output()
|
if err != nil {
|
return ""
|
}
|
return string(host)
|
}
|
|
// 备份nginx配置文件到tmp文件夹, 然后修改端口和域名, 使用nginx -t 验证, 成功则重启nginx, 失败则恢复原配置文件
|
func SetNginxConf(port, host string) bool {
|
_, err := os.Stat(ngConfig)
|
if err != nil {
|
return false
|
}
|
|
// 备份
|
backupFilePath := "/tmp/openresty-smart-ai.conf"
|
cmd := exec.Command("/bin/sh", "-c", "cp -f %s %s", ngConfig, backupFilePath)
|
cmd.Run()
|
|
// 修改配置文件端口
|
cmdStr := fmt.Sprintf("sed -i 's/listen.*/listen %s;/' %s", port, ngConfig)
|
_, err = execRootCommand(cmdStr)
|
|
// 修改配置文件端口
|
cmdStr = fmt.Sprintf("sed -i 's/server_name.*/server_name %s;/' %s", host, ngConfig)
|
_, err = execRootCommand(cmdStr)
|
|
_, err = execRootCommand("/usr/local/openresty/nginx/sbin/nginx -t")
|
if err != nil {
|
cmdStr = fmt.Sprintf("cp -f %s %s", backupFilePath, ngConfig)
|
execRootCommand(cmdStr)
|
return false
|
}
|
|
// 重启nginx
|
_, err = execRootCommand("service openresty reload")
|
|
return err == nil
|
}
|
|
//设置语言
|
func SetLang(lang string, language string) error {
|
// set env
|
envCMD := exec.Command("/bin/sh", "-c", "LANG=%s", lang)
|
envCMD.Run()
|
// change permanent to the file '.profile'
|
cleanTZ := exec.Command("/bin/sh", "-c", "sed -i '/^LANG=.*$/d' ~/.profile")
|
cleanTZ.Run()
|
|
LANG := "LANG='" + lang + "'; export LANG"
|
appendTZCMD := fmt.Sprintf("echo \"%s\" >> ~/.profile;", LANG)
|
appendTZ := exec.Command("/bin/sh", "-c", appendTZCMD)
|
appendTZ.Run()
|
|
// set env
|
envCMD = exec.Command("/bin/sh", "-c", "LANGUAGE=%s", language)
|
envCMD.Run()
|
// change permanent to the file '.profile'
|
cleanTZ = exec.Command("/bin/sh", "-c", "sed -i '/^LANGUAGE=.*$/d' ~/.profile")
|
cleanTZ.Run()
|
|
LANGUAGE := "LANGUAGE='" + lang + "'; export LANGUAGE"
|
appendTZCMD = fmt.Sprintf("echo \"%s\" >> ~/.profile;", LANGUAGE)
|
appendTZ = exec.Command("/bin/sh", "-c", appendTZCMD)
|
appendTZ.Run()
|
|
cmdStr := fmt.Sprintf("sed -i 's/LANG=.*/LANG=\"%s\"/' /etc/default/locale", lang)
|
_, err := execRootCommand(cmdStr)
|
cmdStr = fmt.Sprintf("sed -i 's/LANGUAGE=.*/LANGUAGE=\"%s\"/' /etc/default/locale", language)
|
_, err = execRootCommand(cmdStr)
|
|
return err
|
}
|
|
//获取当前语言
|
func GetLang() (string, error) {
|
content, err := execRootCommand("cat /etc/default/locale|grep LANG")
|
if nil == err {
|
reg, err := regexp.Compile(`LANG="(.*)"`)
|
if nil == err {
|
match := reg.FindSubmatch(content)
|
if len(match) > 1 {
|
return string(match[1]), nil
|
}
|
return "", nil
|
}
|
}
|
return "", err
|
}
|
|
//获取默认键盘布局
|
func GetDefKeyboard() (string, error) {
|
content, err := execRootCommand("cat /etc/default/keyboard|grep XKBLAYOUT")
|
if nil == err {
|
reg, err := regexp.Compile(`XKBLAYOUT="(.*)"`)
|
if nil == err {
|
match := reg.FindSubmatch(content)
|
if len(match) > 1 {
|
return string(match[1]), nil
|
}
|
return "", nil
|
}
|
}
|
return "", err
|
}
|
|
//获取键盘布局
|
func GetKeyboardLayouts() (map[string]string, []sysVo.KeyBoardLayout, error) {
|
output, err := execRootCommand("man -P cat xkeyboard-config")
|
if nil != err {
|
return nil, nil, err
|
}
|
useLine := false
|
lines := strings.Split(string(output), "\n")
|
keybordLayoutsLines := make([]string, 0, len(lines))
|
for _, item := range lines {
|
if strings.HasPrefix(item, "LAYOUTS") {
|
useLine = true
|
continue
|
}
|
if strings.HasPrefix(item, "OPTIONS") {
|
useLine = false
|
}
|
if useLine && !strings.Contains(item, "Layout") {
|
keybordLayoutsLines = append(keybordLayoutsLines, item)
|
}
|
}
|
defkeybord, err := GetDefKeyboard()
|
keyBoardLayoutMap := make(map[string]string, 0)
|
keyBoardLayouts := make([]sysVo.KeyBoardLayout, 0)
|
defFound := false
|
if defkeybord == "" {
|
defFound = true
|
}
|
for _, item := range keybordLayoutsLines {
|
reg, err := regexp.Compile(`│.+│`)
|
if err == nil {
|
line := reg.Find([]byte(item))
|
if nil != line {
|
info := strings.Trim(string(line), "│")
|
reg, err = regexp.Compile(`\s+`)
|
if err == nil {
|
info = reg.ReplaceAllString(info, " ")
|
info := strings.TrimSpace(info)
|
if "" != info {
|
parts := strings.Split(info, " ")
|
if len(parts) >= 2 {
|
keyBoardLayoutMap[parts[0]] = strings.Join(parts[1:], " ")
|
if len(keyBoardLayouts) < 5 && defFound || len(keyBoardLayouts) < 4 {
|
keyBoardLayouts = append(keyBoardLayouts, sysVo.KeyBoardLayout{Id: parts[0], Name: keyBoardLayoutMap[parts[0]]})
|
if parts[0] == defkeybord {
|
defFound = true
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
return keyBoardLayoutMap, keyBoardLayouts, nil
|
}
|
|
//设置键盘布局
|
func SetKeyboardLayout(layout string) error {
|
cmdStr := fmt.Sprintf("sed -i 's/XKBLAYOUT=.*/XKBLAYOUT=\"%s\"/' /etc/default/keyboard", layout)
|
_, err := execRootCommand(cmdStr)
|
|
return err
|
}
|
|
//关闭网络
|
func DownNetCard(networkAdapter string) error {
|
cmdStr := fmt.Sprintf("ip link set %s down", networkAdapter)
|
_, err := execRootCommand(cmdStr)
|
|
return err
|
}
|
|
//开启网络
|
func UpNetCard(networkAdapter string) error {
|
_, _, err := GetLocalIP(networkAdapter)
|
if err != nil {
|
return errors.New("IPv4尚未配置，请配置后开启")
|
}
|
cmdStr := fmt.Sprintf("ip link set %s up", networkAdapter)
|
_, err = execRootCommand(cmdStr)
|
|
return err
|
}
|
|
//获取无线网卡
|
func GetIwDev() ([]string, error) {
|
content, err := execRootCommand("iw dev")
|
if nil == err {
|
reg, err := regexp.Compile(`Interface ([^\n]+)\n`)
|
if nil == err {
|
match := reg.FindAllSubmatch(content, -1)
|
netcards := make([]string, 0)
|
for _, item := range match {
|
if len(item) >= 1 {
|
netcards = append(netcards, string(item[1]))
|
}
|
}
|
return netcards, nil
|
} else {
|
return nil, errors.New("regexp complie failed")
|
}
|
}
|
return nil, errors.New("iw dev not found")
|
}
|
|
//获取wifi网络
|
func GetWifi(netcard string) ([]sysVo.WiFi, error) {
|
reg, err := regexp.Compile(`Quality=(\d+)/70[^\n]+\n\s+Encryption key:([^\n]+)\n\s+ESSID:\"([^\"]+)\"`)
|
if nil == err {
|
var wifiList = make([]sysVo.WiFi, 0)
|
info, err := execRootCommand(fmt.Sprintf("iwlist %s scan", netcard))
|
if nil == err {
|
res := reg.FindAllStringSubmatch(string(info), -1)
|
for _, item := range res {
|
if len(item) >= 4 {
|
wifi := sysVo.WiFi{item[3], item[1], item[2]}
|
wifiList = append(wifiList, wifi)
|
}
|
}
|
return wifiList, nil
|
}
|
}
|
return nil, err
|
}
|
|
//连接WIFI
|
func ConnectWifi(fname, passwd, ssid string) error {
|
content, err := execRootCommand(fmt.Sprintf("wpa_cli -i %s add_network", fname))
|
if nil != err {
|
return err
|
}
|
newid := strings.TrimSpace(string(content))
|
reg, err := regexp.Compile(`^(\d+)$`)
|
if nil == err {
|
b := reg.MatchString(newid)
|
if !b {
|
return errors.New("WIFI加入失败")
|
}
|
ret, err := execRootCommand(fmt.Sprintf("wpa_cli -i %s set_network %s ssid '\"%s\"'", fname, newid, ssid))
|
if nil != err {
|
return err
|
}
|
if strings.TrimSpace(string(ret)) != "OK" {
|
return errors.New(string(ret))
|
}
|
ret, err = execRootCommand(fmt.Sprintf("wpa_cli -i %s set_network %s psk '\"%s\"'", fname, newid, passwd))
|
if nil != err {
|
return err
|
}
|
if strings.TrimSpace(string(ret)) != "OK" {
|
return errors.New(string(ret))
|
}
|
ret, err = execRootCommand(fmt.Sprintf("wpa_cli -i %s disconnect", fname))
|
if nil != err {
|
return err
|
}
|
if strings.TrimSpace(string(ret)) != "OK" {
|
return errors.New(string(ret))
|
}
|
ret, err = execRootCommand(fmt.Sprintf("wpa_cli -i %s select_network %s", fname, newid))
|
if nil != err {
|
return err
|
}
|
if strings.TrimSpace(string(ret)) != "OK" {
|
return errors.New(string(ret))
|
}
|
_, err = execRootCommand(fmt.Sprintf("udhcpc -i %s -q -n", fname))
|
if nil != err {
|
return errors.New("密码好像不对哦")
|
}
|
_, err = execRootCommand(fmt.Sprintf("wpa_cli -i %s save_config", fname))
|
return nil
|
} else {
|
return err
|
}
|
}
|
|
func ExistService(name string) string {
|
b, err := execRootCommand(fmt.Sprintf("which %s", name))
|
if err != nil {
|
return ""
|
}
|
return string(b)
|
}
|
|
//配置mqtt
|
func SetMqttConf(conf *sysVo.MqttConf) error {
|
etcPath := "/etc/mosquitto/mosquitto.conf"
|
pwfile := "/etc/mosquitto/pwfile"
|
//处理是否允许匿名连接mqtt server
|
b, _ := execRootCommand(fmt.Sprintf("cat %s|grep -E 'allow_anonymous false|allow_anonymous true'", etcPath))
|
if string(b) == "" {
|
_, err := execRootCommand(fmt.Sprintf("sh -c \"echo 'allow_anonymous %s' >> %s\"", strconv.FormatBool(conf.AnonymousEnable), etcPath))
|
if err != nil {
|
logger.Error("2 err:", err)
|
return err
|
}
|
} else {
|
_, err := execRootCommand(fmt.Sprintf("sed -i 's/\"%s\"/allow_anonymous \"%s\"/' %s", string(b), strconv.FormatBool(conf.AnonymousEnable), etcPath))
|
if err != nil {
|
logger.Error("3 err:", err)
|
return err
|
}
|
}
|
//处理pwfile
|
if !conf.AnonymousEnable && conf.Username != "" && conf.Password != "" {
|
//1.在/etc/mosquitto/文件夹下生成pwfile文件
|
mos_user_pwd := OutputNewPassword(conf.Username, conf.Password)
|
_, err := execRootCommand(fmt.Sprintf("echo %s > %s", mos_user_pwd, pwfile))
|
if err != nil {
|
logger.Error("4 err:", err)
|
return err
|
}
|
//2.修改/etc/mosquitto/mosquitto.conf中password_file的配置
|
es, _ := execRootCommand(fmt.Sprintf("cat %s |grep -v '#'|grep password_file|head -1", etcPath))
|
pwdSet := "password_file " + pwfile
|
if string(es) == "" {
|
_, err = execRootCommand(fmt.Sprintf("echo %s >> %s", pwdSet, etcPath))
|
if err != nil {
|
logger.Error("6 err:", err)
|
return err
|
}
|
} else {
|
_, err = execRootCommand(fmt.Sprintf("sed -i 's/\"%s\"/\"%s\"/' %s", string(b), pwdSet, etcPath))
|
if err != nil {
|
logger.Error("7 err:", err)
|
return err
|
}
|
}
|
}
|
|
if conf.Enable { //启用mqtt server服务
|
_, err := execRootCommand("systemctl enable mosquitto")
|
if err != nil {
|
logger.Error("8 err:", err)
|
return err
|
}
|
_, err = execRootCommand("systemctl restart mosquitto")
|
if err != nil {
|
logger.Error("9 err:", err)
|
return err
|
}
|
} else {
|
_, err := execRootCommand("systemctl disable mosquitto")
|
if err != nil {
|
logger.Error("10 err:", err)
|
return err
|
}
|
_, err = execRootCommand("systemctl stop mosquitto")
|
if err != nil {
|
logger.Error("11 err:", err)
|
return err
|
}
|
}
|
|
return nil
|
}
|
