fmt

main.go

@@ -8,10 +8,10 @@ import (
 	"fmt"
 	"github.com/gin-gonic/gin"
 
-	"net/http"
-	"time"
 	clog "github.com/33cn/chain33/common/log"
 	log "github.com/33cn/chain33/common/log/log15"
+	"net/http"
+	"time"
 )
 
 func init() {
@@ -26,7 +26,6 @@ func init() {
 
 var tlog = log.New("main", "main.go")
 
-
 // @title Golang Gin API
 // @version 1.0
 // @description An example of gin
@@ -38,7 +37,7 @@ func main() {
 	//区域网广播设备
 	go app.Broadcast()
 	//节点操作
-	go app.BityuanJob(time.NewTicker(time.Second*30))
+	go app.BityuanJob(time.NewTicker(time.Second * 30))
 	//树莓派内置程序操作
 	go app.PaiJob(time.NewTicker(time.Second * 50))
 	//go app.ClearLog(time.NewTicker(time.Hour*1))
@@ -60,7 +59,7 @@ func main() {
 		MaxHeaderBytes: maxHeaderBytes,
 	}
 
-	tlog.Info("[info] start http server listening ", "port",endPoint)
+	tlog.Info("[info] start http server listening ", "port", endPoint)
 	server.ListenAndServe()
 	select {}
 	// If you want Graceful Restart, you need a Unix system and download github.com/fvbock/endless

pkg/app/broadcast.go

 package app
 
 import (
-	"chain33-pai/service/pai_service"
 	"chain33-pai/pkg/util"
+	"chain33-pai/service/pai_service"
 	"net"
 	"time"
 )
@@ -25,10 +25,10 @@ func Broadcast()  {
 		}
 	}
 	//ip 会变化
-	ip,err := util.GetLocalIpByName("wlan0")
+	ip, err := util.GetLocalIpByName("wlan0")
 	if err != nil || ip == nil {
-		tlog.Error("broadcast",err)
-		ip,err = util.GetLocalIpByName("eth0")
+		tlog.Error("broadcast", err)
+		ip, err = util.GetLocalIpByName("eth0")
 		if err != nil {
 			panic(err)
 		}
@@ -46,21 +46,21 @@ func Broadcast()  {
 	}
 	conn, err := net.DialUDP("udp", &laddr, &raddr)
 	if err != nil {
-		tlog.Error("broadcast","net error ",err)
+		tlog.Error("broadcast", "net error ", err)
 		panic(err)
 	}
 	for {
 		//ip 会变化
-		ip,err = util.GetLocalIpByName("wlan0")
+		ip, err = util.GetLocalIpByName("wlan0")
 		if err != nil || ip == nil {
-			tlog.Error("broadcast","err","wlan0 not exists")
-			ip,err = util.GetLocalIpByName("eth0")
+			tlog.Error("broadcast", "err", "wlan0 not exists")
+			ip, err = util.GetLocalIpByName("eth0")
 			if err != nil {
-				tlog.Error("broadcast","err","eth0 not exists")
-				time.Sleep(time.Second*1)
+				tlog.Error("broadcast", "err", "eth0 not exists")
+				time.Sleep(time.Second * 1)
 				continue
 			}
-			tlog.Info("broadcast","eth0",ip.IP.String())
+			tlog.Info("broadcast", "eth0", ip.IP.String())
 		}
 
 		if runningAddr != nil && runningAddr.IP.String() != ip.IP.String() {
@@ -76,22 +76,22 @@ func Broadcast()  {
 			conn.Close()
 			conn, err = net.DialUDP("udp", &laddr, &raddr)
 			if err != nil {
-				tlog.Error("broadcast","net error ",err)
+				tlog.Error("broadcast", "net error ", err)
 				panic(err)
 			}
-			tlog.Info("broadcast","oldip",runningAddr.IP.String(),"newip",ip.IP.String())
+			tlog.Info("broadcast", "oldip", runningAddr.IP.String(), "newip", ip.IP.String())
 
 		}
 
 		runningAddr = ip
 		_, err = conn.Write([]byte(send))
-		if err != nil{
-			tlog.Error("broadcast ","err",err)
-			time.Sleep(time.Second*1)
+		if err != nil {
+			tlog.Error("broadcast ", "err", err)
+			time.Sleep(time.Second * 1)
 			continue
 		}
-		tlog.Info("broadcast","ip:",ip.IP.String(),"udp",send)
-		time.Sleep(time.Second*1)
+		tlog.Info("broadcast", "ip:", ip.IP.String(), "udp", send)
+		time.Sleep(time.Second * 1)
 
 	}
 

pkg/app/init.go

@@ -7,5 +7,5 @@ type MsgType struct {
 }
 
 func Setup() {
-	JobChan = make(chan MsgType,10)
+	JobChan = make(chan MsgType, 10)
 }

pkg/app/raspberryChan.go

 package app
 
 import (
-	"time"
-	"chain33-pai/pkg/setting"
 	"bytes"
-	"os/exec"
-	"fmt"
+	"chain33-pai/pkg/setting"
 	"chain33-pai/service/pai_service"
 	"errors"
+	"fmt"
 	"os"
+	"os/exec"
+	"time"
 )
 
 var (
@@ -17,8 +17,8 @@ var (
 
 func RaspberryChan() {
 	for {
-		if value,ok := <- JobChan; ok {
-			tlog.Info("raspberrychan","msg",value)
+		if value, ok := <-JobChan; ok {
+			tlog.Info("raspberrychan", "msg", value)
 			if value.Name == "" {
 				continue
 			}
@@ -30,37 +30,37 @@ func RaspberryChan() {
 			case "ROLLBACK":
 				err := rollback()
 				if err == nil {
-					tlog.Info("rollback success","err",nil)
+					tlog.Info("rollback success", "err", nil)
 				} else {
-					tlog.Error("rollback fail ","err",err)
+					tlog.Error("rollback fail ", "err", err)
 				}
 			case "BACKUP":
 				err := backup()
 				if err == nil {
-					tlog.Info("backup success","err",nil)
+					tlog.Info("backup success", "err", nil)
 				} else {
-					tlog.Error("backup fail ","err",err)
+					tlog.Error("backup fail ", "err", err)
 				}
 			case "RECOVER":
 				err := recoverNode()
 				if err == nil {
-					tlog.Info("recover success","err",nil)
+					tlog.Info("recover success", "err", nil)
 				} else {
-					tlog.Error("recover fail ","err",err)
+					tlog.Error("recover fail ", "err", err)
 				}
 			case "DELETEBACKUP":
 				err := deleteBackup()
 				if err == nil {
-					tlog.Info("deleteBackup success","err",nil)
+					tlog.Info("deleteBackup success", "err", nil)
 				} else {
-					tlog.Error("deleteBackup fail ","err",err)
+					tlog.Error("deleteBackup fail ", "err", err)
 				}
 			case "RESTART":
 				err := restartNode()
 				if err == nil {
-					tlog.Info("deleteBackup success","err",nil)
+					tlog.Info("deleteBackup success", "err", nil)
 				} else {
-					tlog.Error("deleteBackup fail ","err",err)
+					tlog.Error("deleteBackup fail ", "err", err)
 				}
 			}
 
@@ -69,12 +69,11 @@ func RaspberryChan() {
 	}
 }
 
-
 func rollback() error {
 	BityuanFlag.Lock.Lock()
 	defer BityuanFlag.Lock.Unlock()
 	BityuanFlag.Flag = true
-	_,err := SafeCloseNode()
+	_, err := SafeCloseNode()
 	if err != nil {
 		BityuanFlag.Flag = false
 		return err
@@ -82,12 +81,12 @@ func rollback() error {
 	var pai pai_service.Pai
 	err = pai.SetPai()
 	if err != nil {
-		tlog.Error("SetPai","err",err)
+		tlog.Error("SetPai", "err", err)
 		BityuanFlag.Flag = false
 		return err
 	}
 	if pai.LocalLastHeight == 0 {
-		tlog.Error("LocalLastHeight","height",pai.LocalLastHeight)
+		tlog.Error("LocalLastHeight", "height", pai.LocalLastHeight)
 		BityuanFlag.Flag = false
 		return err
 	}
@@ -100,21 +99,21 @@ func rollback() error {
 		BityuanFlag.Flag = false
 		return errors.New("bty is running")
 	}
-	tlog.Info("rollback start","height",pai.LocalLastHeight,"rollbackheight",rollheight)
+	tlog.Info("rollback start", "height", pai.LocalLastHeight, "rollbackheight", rollheight)
 	var buf bytes.Buffer
 	if btyPath == "" {
-		tlog.Error("GetAbsPath","err","btyPath not exists")
+		tlog.Error("GetAbsPath", "err", "btyPath not exists")
 		BityuanFlag.Flag = false
 		return err
 	}
-	cmd := exec.Command(btyPath+"/"+setting.BityuanSetting.Name, "-rollback",fmt.Sprintf("%d",rollheight))
+	cmd := exec.Command(btyPath+"/"+setting.BityuanSetting.Name, "-rollback", fmt.Sprintf("%d", rollheight))
 	cmd.Stdout = &buf
 	err = cmd.Run()
 	if err != nil {
 		BityuanFlag.Flag = false
 		return err
 	}
-	tlog.Info("rollback end","height",pai.LocalLastHeight,"rollbackheight",rollheight)
+	tlog.Info("rollback end", "height", pai.LocalLastHeight, "rollbackheight", rollheight)
 	BityuanFlag.Flag = false
 	return nil
 }
@@ -126,10 +125,10 @@ func backup() error {
 		return errors.New("env err")
 	}
 	BityuanFlag.Flag = true
-	ok,err := SafeCloseNode()
+	ok, err := SafeCloseNode()
 	if err != nil {
 		BityuanFlag.Flag = false
-		tlog.Error("SafeCloseNode","err",err)
+		tlog.Error("SafeCloseNode", "err", err)
 		return err
 	}
 	if !ok {
@@ -142,7 +141,7 @@ func backup() error {
 		return errors.New("bty is running")
 	}
 	err = deleteBackup()
-	if err != nil && err != errors.New("backup file not exists"){
+	if err != nil && err != errors.New("backup file not exists") {
 		BityuanFlag.Flag = false
 		return err
 	}
@@ -158,13 +157,13 @@ func backup() error {
 func SafeBackup() error {
 	s := time.Now()
 	defer func() {
-		tlog.Info("SafeBackup","cost",time.Since(s))
+		tlog.Info("SafeBackup", "cost", time.Since(s))
 	}()
 	var buf bytes.Buffer
-	backup := exec.Command("cp","-r",btyPath+"/datadir",btyPath+"/datadir_backup")
+	backup := exec.Command("cp", "-r", btyPath+"/datadir", btyPath+"/datadir_backup")
 	backup.Stderr = &buf
-	if err := backup.Run();err != nil {
-		tlog.Error("SafeBackup","err",buf.String())
+	if err := backup.Run(); err != nil {
+		tlog.Error("SafeBackup", "err", buf.String())
 		return err
 	}
 	return nil
@@ -174,10 +173,10 @@ func recoverNode() error {
 	BityuanFlag.Lock.Lock()
 	defer BityuanFlag.Lock.Unlock()
 	if btyPath == "" {
-		tlog.Error("btyPath empty","err","node not exists")
+		tlog.Error("btyPath empty", "err", "node not exists")
 		return errors.New("node not exists")
 	}
-	_,err := SafeCloseNode()
+	_, err := SafeCloseNode()
 	if err != nil {
 		return err
 	}
@@ -186,23 +185,23 @@ func recoverNode() error {
 		return errors.New("bty is running")
 	}
 	backupPath := btyPath + "/datadir_backup"
-	if _,err := os.Stat(backupPath);err != nil {
+	if _, err := os.Stat(backupPath); err != nil {
 		if os.IsNotExist(err) {
-			tlog.Error("backup file not exists","err",backupPath)
+			tlog.Error("backup file not exists", "err", backupPath)
 			return errors.New("backup file not exists")
 		}
 	}
-	remove := exec.Command("rm","-rf",btyPath+"/datadir")
+	remove := exec.Command("rm", "-rf", btyPath+"/datadir")
 	err = remove.Run()
 	if err != nil {
-		tlog.Error("rm -rf datadir","err",err)
+		tlog.Error("rm -rf datadir", "err", err)
 		return err
 	}
 
-	recover := exec.Command("cp","-r",backupPath,btyPath+"/datadir")
+	recover := exec.Command("cp", "-r", backupPath, btyPath+"/datadir")
 	err = recover.Run()
 	if err != nil {
-		tlog.Error("cp -r datadir_backup datadir","err",err)
+		tlog.Error("cp -r datadir_backup datadir", "err", err)
 		return err
 	}
 	StartProcess(setting.Chain33Pai.Auto)
@@ -212,33 +211,32 @@ func recoverNode() error {
 func deleteBackup() error {
 	s := time.Now()
 	defer func() {
-		tlog.Info("deleteBackup","cost",time.Since(s))
+		tlog.Info("deleteBackup", "cost", time.Since(s))
 	}()
 	backupPath := btyPath + "/datadir_backup"
-	if _,err := os.Stat(backupPath);err != nil {
+	if _, err := os.Stat(backupPath); err != nil {
 		if os.IsNotExist(err) {
-			tlog.Error("backup file not exists","err",backupPath)
+			tlog.Error("backup file not exists", "err", backupPath)
 			return nil
 		}
 	}
-	remove := exec.Command("rm","-rf",backupPath)
+	remove := exec.Command("rm", "-rf", backupPath)
 	err := remove.Run()
 	if err != nil {
-		tlog.Error("rm -rf datadir_backup","err",err)
+		tlog.Error("rm -rf datadir_backup", "err", err)
 		return err
 	}
 	return nil
 }
 
-
 func restartNode() error {
 	BityuanFlag.Lock.Lock()
 	defer BityuanFlag.Lock.Unlock()
 	if btyPath == "" {
-		tlog.Error("btyPath empty","err","node not exists")
+		tlog.Error("btyPath empty", "err", "node not exists")
 		return errors.New("node not exists")
 	}
-	_,err := SafeCloseNode()
+	_, err := SafeCloseNode()
 	if err != nil {
 		return err
 	}
@@ -253,7 +251,7 @@ func restartNode() error {
 func MakeSureBtyIsNotRun() bool {
 	s := time.Now()
 	defer func() {
-		tlog.Info("MakeSureBtyIsNotRun","cost",time.Since(s))
+		tlog.Info("MakeSureBtyIsNotRun", "cost", time.Since(s))
 	}()
 	num := 0
 	for {
@@ -265,7 +263,7 @@ func MakeSureBtyIsNotRun() bool {
 			return false
 		}
 		num++
-		time.Sleep(time.Second*1)
+		time.Sleep(time.Second * 1)
 	}
 	return true
 }

pkg/app/version.go

@@ -8,7 +8,7 @@ var (
 
 func GetVersion() string {
 	if GitCommit != "" {
-		return version+"-"+GitCommit
+		return version + "-" + GitCommit
 	}
 	return version
 }

pkg/chain33/client.go

@@ -2,13 +2,11 @@ package chain33
 
 import (
 	"context"
-	"google.golang.org/grpc"
 	"github.com/33cn/chain33/types"
-
+	"google.golang.org/grpc"
 )
 
 type PaiClient struct {
-
 }
 
 var (
@@ -17,42 +15,42 @@ var (
 )
 
 func init() {
-	maxReceLimit := grpc.WithMaxMsgSize(30*1024*1024)
-	conn, err := grpc.Dial(paiNetgrpcAddr, grpc.WithInsecure(),maxReceLimit)
+	maxReceLimit := grpc.WithMaxMsgSize(30 * 1024 * 1024)
+	conn, err := grpc.Dial(paiNetgrpcAddr, grpc.WithInsecure(), maxReceLimit)
 	if err != nil {
 		panic(err)
 	}
 	paiClient = types.NewChain33Client(conn)
 }
 
-func (p *PaiClient) GetWalletStatus() (*types.WalletStatus,error) {
-	return paiClient.GetWalletStatus(context.Background(),&types.ReqNil{})
+func (p *PaiClient) GetWalletStatus() (*types.WalletStatus, error) {
+	return paiClient.GetWalletStatus(context.Background(), &types.ReqNil{})
 }
 
-func (p *PaiClient) GetPeerInfo() (*types.PeerList,error) {
-	return paiClient.GetPeerInfo(context.Background(),&types.P2PGetPeerReq{})
+func (p *PaiClient) GetPeerInfo() (*types.PeerList, error) {
+	return paiClient.GetPeerInfo(context.Background(), &types.P2PGetPeerReq{})
 }
 
-func (p *PaiClient) IsNtpClockSync() (*types.Reply,error) {
-	return paiClient.IsNtpClockSync(context.Background(),&types.ReqNil{})
+func (p *PaiClient) IsNtpClockSync() (*types.Reply, error) {
+	return paiClient.IsNtpClockSync(context.Background(), &types.ReqNil{})
 }
 
-func (p *PaiClient) GetNetInfo() (*types.NodeNetInfo,error) {
-	return paiClient.NetInfo(context.Background(),&types.P2PGetNetInfoReq{})
+func (p *PaiClient) GetNetInfo() (*types.NodeNetInfo, error) {
+	return paiClient.NetInfo(context.Background(), &types.P2PGetNetInfoReq{})
 }
 
-func (p *PaiClient) Version()(*types.VersionInfo,error){
-	return paiClient.Version(context.Background(),&types.ReqNil{})
+func (p *PaiClient) Version() (*types.VersionInfo, error) {
+	return paiClient.Version(context.Background(), &types.ReqNil{})
 }
 
-func (p *PaiClient) Close() (*types.Reply,error) {
-	return paiClient.CloseQueue(context.Background(),&types.ReqNil{})
+func (p *PaiClient) Close() (*types.Reply, error) {
+	return paiClient.CloseQueue(context.Background(), &types.ReqNil{})
 }
 
-func (p *PaiClient) Unlock(lock *types.WalletUnLock)(*types.Reply,error){
-	return paiClient.UnLock(context.Background(),lock)
+func (p *PaiClient) Unlock(lock *types.WalletUnLock) (*types.Reply, error) {
+	return paiClient.UnLock(context.Background(), lock)
 }
 
-func (p *PaiClient) IsSync() (*types.Reply,error) {
-	return paiClient.IsSync(context.Background(),&types.ReqNil{})
+func (p *PaiClient) IsSync() (*types.Reply, error) {
+	return paiClient.IsSync(context.Background(), &types.ReqNil{})
 }

pkg/e/code.go

@@ -7,7 +7,7 @@ const (
 
 	NETWORK_ERROR         = 5004
 	NODE_ERROR            = 5000
-	SUCCESS_RUNNING= 5002
+	SUCCESS_RUNNING       = 5002
 	ENV_ERROR             = 5001
 	DOWNLOAD_ERROR        = 5005
 	TAR_XVF_ERROR         = 5006

pkg/logging/log.go

 package logging
 
 import (
-	"fmt"
 	"chain33-pai/pkg/file"
+	"fmt"
 	"log"
 	"os"
 	"path/filepath"

pkg/pai/pai.go

 package pai
 
 import (
-	"os/exec"
-	"io/ioutil"
-	"strings"
+	"bytes"
 	"chain33-pai/pkg/util"
 	"github.com/33cn/chain33/common/log"
-	"bytes"
+	"io/ioutil"
+	"os/exec"
+	"strings"
 )
 
-var tlog = log.New("pkg","pai")
+var tlog = log.New("pkg", "pai")
 
-func MonitorServer() ([]*Disk,error) {
+func MonitorServer() ([]*Disk, error) {
 	//获取硬盘情况
-	cmd := exec.Command("df","-T")
+	cmd := exec.Command("df", "-T")
 	stdout, err := cmd.StdoutPipe()
 	err = cmd.Start()
 	if err != nil {
-		tlog.Info("MonitorServer","df -T start " ,err)
-		return nil,err
+		tlog.Info("MonitorServer", "df -T start ", err)
+		return nil, err
 	}
 	content, err := ioutil.ReadAll(stdout)
 	if err != nil {
-		tlog.Info("MonitorServer","ioutil readd err",err)
-		return nil,err
+		tlog.Info("MonitorServer", "ioutil readd err", err)
+		return nil, err
 	}
 	err = cmd.Wait()
 	if err != nil {
-		tlog.Info("MonitorServer","df -T end" ,err)
-		return nil,err
+		tlog.Info("MonitorServer", "df -T end", err)
+		return nil, err
 	}
-	tlog.Info("MonitorServer","content",string(content))
-	list := strings.Split(string(content),"\n")
-	tempDisk := make([]*Disk,0)
-	for _,v := range list {
-		c := strings.Contains(v,"/dev/sd")
+	tlog.Info("MonitorServer", "content", string(content))
+	list := strings.Split(string(content), "\n")
+	tempDisk := make([]*Disk, 0)
+	for _, v := range list {
+		c := strings.Contains(v, "/dev/sd")
 		if c {
 			tempD := &Disk{}
-			params := strings.Split(util.DeleteExtraSpace(v)," ")
+			params := strings.Split(util.DeleteExtraSpace(v), " ")
 			if len(params) == 7 {
 				tempD.Filesystem = params[0]
 				tempD.Type = params[1]
 				tempD.SizeK = params[2]
 				tempD.Use = params[5]
-				tempDisk = append(tempDisk,tempD)
+				tempDisk = append(tempDisk, tempD)
 			} else {
 				break
 			}
 		}
 	}
-	return tempDisk,nil
+	return tempDisk, nil
 }
 
-
 func FindAbsPath(name string) string {
 	var buffer bytes.Buffer
-	cmd:=exec.Command("find","/media","-name",name)
-	cmd.Stdout=&buffer
+	cmd := exec.Command("find", "/media", "-name", name)
+	cmd.Stdout = &buffer
 	cmd.Start()
 	cmd.Wait()
 	if buffer.String() == "" {
-		tlog.Error("FindAbsPath","ERR","node path not exists")
+		tlog.Error("FindAbsPath", "ERR", "node path not exists")
 		return ""
 	}
-	pathlist := strings.Split(buffer.String(),"\n")
+	pathlist := strings.Split(buffer.String(), "\n")
 	return pathlist[0]
 }

pkg/pai/types.go

@@ -2,7 +2,7 @@ package pai
 
 type Disk struct {
 	Filesystem string `json:"filesystem"`
-	Type string `json:"type"`//硬盘格式
-	SizeK string `json:"size_k"`//硬盘大小
+	Type       string `json:"type"`   //硬盘格式
+	SizeK      string `json:"size_k"` //硬盘大小
 	Use        string `json:"use"`
 }

pkg/setting/setting.go

 package setting
 
 import (
-	"log"
-	"time"
-	"os/exec"
 	"chain33-pai/pkg/chain33"
-	"github.com/go-ini/ini"
 	"github.com/33cn/chain33/types"
-
+	"github.com/go-ini/ini"
+	"log"
+	"os/exec"
+	"time"
 )
 
 var PaiClient *chain33.PaiClient
@@ -63,6 +62,7 @@ type Redis struct {
 	MaxActive   int
 	IdleTimeout time.Duration
 }
+
 var RedisSetting = &Redis{}
 
 type Bityuan struct {
@@ -73,7 +73,8 @@ type Bityuan struct {
 	Version     string
 	VersionPath string
 }
-var BityuanSetting=&Bityuan{}
+
+var BityuanSetting = &Bityuan{}
 
 type Chain33_pai struct {
 	Name               string
@@ -93,10 +94,10 @@ type Chain33_pai struct {
 	UploadVersionUrl   string
 	UploadTestUrl      string
 }
-var Chain33Pai=&Chain33_pai{}
 
+var Chain33Pai = &Chain33_pai{}
 
-var LogSetting=&types.Log{}
+var LogSetting = &types.Log{}
 
 var cfg *ini.File
 
@@ -110,10 +111,10 @@ func Setup() {
 	mapTo("app", AppSetting)
 	mapTo("redis", RedisSetting)
 	mapTo("server", ServerSetting)
-	mapTo("chain33-pai",Chain33Pai)
-	mapTo("bityuan",BityuanSetting)
+	mapTo("chain33-pai", Chain33Pai)
+	mapTo("bityuan", BityuanSetting)
 	mapTo("database", DatabaseSetting)
-	mapTo("log",LogSetting)
+	mapTo("log", LogSetting)
 	AppSetting.ImageMaxSize = AppSetting.ImageMaxSize * 1024 * 1024
 	ServerSetting.ReadTimeout = ServerSetting.ReadTimeout * time.Second
 	ServerSetting.WriteTimeout = ServerSetting.WriteTimeout * time.Second
@@ -121,20 +122,20 @@ func Setup() {
 
 }
 
-func FreshVersion(){
-		version,err:=PaiClient.Version()
-		if err!=nil{
-			auto:=exec.Command(Chain33Pai.Auto)
-			err=auto.Start()
+func FreshVersion() {
+	version, err := PaiClient.Version()
+	if err != nil {
+		auto := exec.Command(Chain33Pai.Auto)
+		err = auto.Start()
 		if err != nil {
 			log.Fatalf("start node failed,need to start manually")
 		}
-			err=auto.Wait()
+		err = auto.Wait()
 		if err != nil {
 			log.Fatalf("start node failed,need to start manually")
 		}
 	}
-		BityuanSetting.Version=version.App
+	BityuanSetting.Version = version.App
 }
 
 // mapTo map section

pkg/util/pagination.go

 package util
 
 import (
-	"github.com/unknwon/com"
 	"github.com/gin-gonic/gin"
+	"github.com/unknwon/com"
 
 	"chain33-pai/pkg/setting"
 )

pkg/util/util.go

@@ -2,12 +2,12 @@ package util
 
 import (
 	"chain33-pai/pkg/setting"
-	"net"
 	"errors"
-	"net/http"
 	"io/ioutil"
-	"strings"
+	"net"
+	"net/http"
 	"regexp"
+	"strings"
 )
 
 // Setup Initialize the util
@@ -31,10 +31,10 @@ func GetLocalIP() (ipv4 *net.IPNet, err error) {
 	// 取第一个非lo的网卡IP
 	for _, addr = range addrs {
 		// 这个网络地址是IP地址: ipv4, ipv6
-		if ipNet, isIpNet = addr.(*net.IPNet); isIpNet && !ipNet.IP.IsLoopback(){
+		if ipNet, isIpNet = addr.(*net.IPNet); isIpNet && !ipNet.IP.IsLoopback() {
 			// 跳过IPV6
-			if ipNet.IP.To4() != nil{
-				ipv4 = ipNet// 192.168.1.1
+			if ipNet.IP.To4() != nil {
+				ipv4 = ipNet // 192.168.1.1
 				return
 			}
 		}
@@ -46,42 +46,41 @@ func GetLocalIP() (ipv4 *net.IPNet, err error) {
 
 func GetLocalIpByName(name string) (ipv4 *net.IPNet, err error) {
 	if name == "" {
-		return nil,errors.New("name not empty")
+		return nil, errors.New("name not empty")
 	}
 
-	inter,err := net.InterfaceByName(name)
+	inter, err := net.InterfaceByName(name)
 	if err != nil {
-		return nil,err
+		return nil, err
 	}
 	var (
 		addrs   []net.Addr
 		ipNet   *net.IPNet // IP地址
 		isIpNet bool
 	)
-	if addrs,err = inter.Addrs(); err != nil {
-		return nil,err
+	if addrs, err = inter.Addrs(); err != nil {
+		return nil, err
 	}
 	for _, addr := range addrs {
-		if ipNet, isIpNet = addr.(*net.IPNet); isIpNet && !ipNet.IP.IsLoopback(){
+		if ipNet, isIpNet = addr.(*net.IPNet); isIpNet && !ipNet.IP.IsLoopback() {
 			// 跳过IPV6
-			if ipNet.IP.To4() != nil{
-				ipv4 = ipNet// 192.168.1.1
+			if ipNet.IP.To4() != nil {
+				ipv4 = ipNet // 192.168.1.1
 				return
 			}
 		}
 	}
-	return nil,nil
+	return nil, nil
 }
 
-
-func GetExternal() (string,error) {
+func GetExternal() (string, error) {
 	resp, err := http.Get("http://myexternalip.com/raw")
 	if err != nil {
-		return "",err
+		return "", err
 	}
 	defer resp.Body.Close()
-	content,_ := ioutil.ReadAll(resp.Body)
-	return string(content),nil
+	content, _ := ioutil.ReadAll(resp.Body)
+	return string(content), nil
 }
 
 //两个以上空格替换成一个空格
@@ -129,4 +128,3 @@ func VersionCompare(version string) string {
 	}
 	return string(vo)
 }
-

routers/api/auth.go

-package api
-
-import (
-	"net/http"
-
-	"github.com/astaxie/beego/validation"
-	"github.com/gin-gonic/gin"
-
-	"chain33-pai/pkg/app"
-	"chain33-pai/pkg/e"
-	"chain33-pai/pkg/util"
-	"chain33-pai/service/auth_service"
-)
-
-type auth struct {
-	Username string `valid:"Required; MaxSize(50)"`
-	Password string `valid:"Required; MaxSize(50)"`
-}
-
-// @Summary Get Auth
-// @Produce  json
-// @Param username query string true "userName"
-// @Param password query string true "password"
-// @Success 200 {object} app.Response
-// @Failure 500 {object} app.Response
-// @Router /auth [get]
-func GetAuth(c *gin.Context) {
-	appG := app.Gin{C: c}
-	valid := validation.Validation{}
-
-	username := c.Query("username")
-	password := c.Query("password")
-
-	a := auth{Username: username, Password: password}
-	ok, _ := valid.Valid(&a)
-
-	if !ok {
-		app.MarkErrors(valid.Errors)
-		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
-		return
-	}
-
-	authService := auth_service.Auth{Username: username, Password: password}
-	isExist, err := authService.Check()
-	if err != nil {
-		appG.Response(http.StatusInternalServerError, e.ERROR_AUTH_CHECK_TOKEN_FAIL, nil)
-		return
-	}
-
-	if !isExist {
-		appG.Response(http.StatusUnauthorized, e.ERROR_AUTH, nil)
-		return
-	}
-
-	token, err := util.GenerateToken(username, password)
-	if err != nil {
-		appG.Response(http.StatusInternalServerError, e.ERROR_AUTH_TOKEN, nil)
-		return
-	}
-
-	appG.Response(http.StatusOK, e.SUCCESS, map[string]string{
-		"token": token,
-	})
-}

routers/api/v1/pai.go

 package v1
 
 import (
-    "os"
-	"net/http"
-	"chain33-pai/pkg/e"
 	"chain33-pai/pkg/app"
-	"github.com/gin-gonic/gin"
-	"chain33-pai/service/pai_service"
+	"chain33-pai/pkg/e"
+	"chain33-pai/pkg/pai"
 	"chain33-pai/pkg/setting"
-	"os/exec"
-	log "github.com/33cn/chain33/common/log/log15"
 	"chain33-pai/pkg/util"
-	"chain33-pai/pkg/pai"
+	"chain33-pai/service/pai_service"
+	log "github.com/33cn/chain33/common/log/log15"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"os"
+	"os/exec"
 )
 
 var tlog = log.New("api", "v1")
@@ -40,18 +40,18 @@ func GetDevstatus(c *gin.Context) {
 
 //获取chain33-pai程序版本
 func GetPaiVersion(c *gin.Context) {
-	appG := app.Gin{C:c}
+	appG := app.Gin{C: c}
 	version := app.GetVersion()
 	var pai pai_service.Pai
 
-	latest,err := pai.GetPaiLatestVersion(int32(2))
+	latest, err := pai.GetPaiLatestVersion(int32(2))
 	if err != nil {
 		appG.Response(http.StatusOK, e.NETWORK_ERROR, nil)
 		return
 	}
 	appG.Response(http.StatusOK, e.SUCCESS, gin.H{
-		"current":version,
-		"latest":latest,
+		"current": version,
+		"latest":  latest,
 	})
 }
 
@@ -59,7 +59,7 @@ func GetPaiVersion(c *gin.Context) {
 //具体更新逻辑写在代码  更新迭代比较麻烦 改为下面new方法
 //下载地址阿里云oss地址  固定ip格式+/+chain33-pai+x.x.x+.tar.gz
 func UpdatePai(c *gin.Context) {
-	appG := app.Gin{C:c}
+	appG := app.Gin{C: c}
 	if app.DPercent.Flag {
 		appG.Response(http.StatusOK, e.DOWNLOAD_ERROR, "正在升级中，不要重复点击")
 		return
@@ -83,7 +83,7 @@ func UpdatePai(c *gin.Context) {
 	}
 	//检查版本号是否存在于online数据库
 	var pai pai_service.Pai
-	latest,err := pai.GetPaiLatestVersion(int32(2))
+	latest, err := pai.GetPaiLatestVersion(int32(2))
 	if err != nil {
 		appG.Response(http.StatusOK, e.DOWNLOAD_ERROR, err)
 		app.DPercent.Flag = false
@@ -96,102 +96,102 @@ func UpdatePai(c *gin.Context) {
 		app.DPercent.Flag = false
 		return
 	}
-	name := setting.Chain33Pai.Name+"_"+req.Version+".tar.gz"
-	url := setting.Chain33Pai.DownloadUrl+ name
+	name := setting.Chain33Pai.Name + "_" + req.Version + ".tar.gz"
+	url := setting.Chain33Pai.DownloadUrl + name
 	//oss下载更新包
-	err = app.DownLoadFile(url,name,int32(2))
+	err = app.DownLoadFile(url, name, int32(2))
 	if err != nil {
 		appG.Response(http.StatusOK, e.DOWNLOAD_ERROR, err)
 		app.DPercent.Flag = false
 		return
 	}
 	//解压缩文件
-	tar := exec.Command("tar","-xvf",name)
+	tar := exec.Command("tar", "-xvf", name)
 	err = tar.Start()
 	if err != nil {
-		tlog.Error("tar","err",err)
+		tlog.Error("tar", "err", err)
 		appG.Response(http.StatusOK, e.TAR_XVF_ERROR, err)
 		app.DPercent.Flag = false
 		return
 	}
 	err = tar.Wait()
 	if err != nil {
-		tlog.Error("tar","err",err)
+		tlog.Error("tar", "err", err)
 		appG.Response(http.StatusOK, e.TAR_XVF_ERROR, err)
 		app.DPercent.Flag = false
 		return
 	}
 	//备份原文件 确保没有alias 关联
-	bak := exec.Command("cp",setting.Chain33Pai.Name,setting.Chain33Pai.Name+".bak")
+	bak := exec.Command("cp", setting.Chain33Pai.Name, setting.Chain33Pai.Name+".bak")
 	err = bak.Start()
 	if err != nil {
-		tlog.Error("bak","err",err)
+		tlog.Error("bak", "err", err)
 		appG.Response(http.StatusOK, e.CP_ERROR, err)
 		app.DPercent.Flag = false
 		return
 	}
 	err = bak.Wait()
 	if err != nil {
-		tlog.Error("bak","err",err)
+		tlog.Error("bak", "err", err)
 		appG.Response(http.StatusOK, e.CP_ERROR, err)
 		app.DPercent.Flag = false
 		return
 	}
 	//备份配置文件
-	bakconf := exec.Command("cp","conf/app.ini","conf/app.ini.bak")
+	bakconf := exec.Command("cp", "conf/app.ini", "conf/app.ini.bak")
 	err = bakconf.Start()
 	if err != nil {
-		tlog.Error("bakconf","err",err)
+		tlog.Error("bakconf", "err", err)
 		appG.Response(http.StatusOK, e.CP_ERROR, err)
 		app.DPercent.Flag = false
 		return
 	}
 	err = bakconf.Wait()
 	if err != nil {
-		tlog.Error("bakconf","err",err)
+		tlog.Error("bakconf", "err", err)
 		appG.Response(http.StatusOK, e.CP_ERROR, err)
 		app.DPercent.Flag = false
 		return
 	}
 	//替换原执行文件
-	mv := exec.Command("mv",setting.Chain33Pai.Name+"_"+req.Version+"/"+setting.Chain33Pai.Name,".")
+	mv := exec.Command("mv", setting.Chain33Pai.Name+"_"+req.Version+"/"+setting.Chain33Pai.Name, ".")
 	err = mv.Start()
 	if err != nil {
-		tlog.Error("mv","err",err)
+		tlog.Error("mv", "err", err)
 		appG.Response(http.StatusOK, e.MV_ERROR, err)
 		app.DPercent.Flag = false
 		return
 	}
 	err = mv.Wait()
 	if err != nil {
-		tlog.Error("mv","err",err)
+		tlog.Error("mv", "err", err)
 		appG.Response(http.StatusOK, e.MV_ERROR, err)
 		app.DPercent.Flag = false
 		return
 	}
 	//替换配置文件
-	mvconf := exec.Command("mv",setting.Chain33Pai.Name+"_"+req.Version+"/conf/app.ini","conf")
+	mvconf := exec.Command("mv", setting.Chain33Pai.Name+"_"+req.Version+"/conf/app.ini", "conf")
 	err = mvconf.Start()
 	if err != nil {
-		tlog.Error("mvconf","err",err)
+		tlog.Error("mvconf", "err", err)
 		appG.Response(http.StatusOK, e.MV_ERROR, err)
 		app.DPercent.Flag = false
 		return
 	}
 	err = mvconf.Wait()
 	if err != nil {
-		tlog.Error("mvconf","err",err)
+		tlog.Error("mvconf", "err", err)
 		appG.Response(http.StatusOK, e.MV_ERROR, err)
 		app.DPercent.Flag = false
 		return
 	}
 	os.RemoveAll("scripts")
-	os.Mkdir("scripts",0600)
+	os.Mkdir("scripts", 0600)
 	//删除temp文件夹
 	//替换原执行文件
-	app.MVScripts(setting.Chain33Pai.Name+"_"+req.Version,".")
+	app.MVScripts(setting.Chain33Pai.Name+"_"+req.Version, ".")
 
-	remove := exec.Command("rm","-rf",setting.Chain33Pai.Name+"_"+req.Version,name)
+	remove := exec.Command("rm", "-rf", setting.Chain33Pai.Name+"_"+req.Version, name)
 	err = remove.Start()
 	if err != nil {
 		appG.Response(http.StatusOK, e.RM_ERROR, err)
@@ -212,7 +212,7 @@ func UpdatePai(c *gin.Context) {
 //忽略req.Version 对比自己版本和最新版本 直接更新覆盖最新版本
 //下载地址阿里云oss地址  固定ip格式+/+chain33-pai+x.x.x+.tar.gz
 func UpdatePaiNew(c *gin.Context) {
-	appG := app.Gin{C:c}
+	appG := app.Gin{C: c}
 	if app.DPercent.Flag {
 		appG.Response(http.StatusOK, e.DOWNLOAD_ERROR, "正在升级中，不要重复点击")
 		return
@@ -238,18 +238,17 @@ func UpdatePaiNew(c *gin.Context) {
 	appG.Response(http.StatusOK, e.SUCCESS, nil)
 }
 
-
 func GetDPercent(c *gin.Context) {
-	appG := app.Gin{C:c}
+	appG := app.Gin{C: c}
 	appG.Response(http.StatusOK, e.SUCCESS, gin.H{
-		"total":app.DPercent.Total,
-		"current":app.DPercent.Current,
+		"total":   app.DPercent.Total,
+		"current": app.DPercent.Current,
 	})
 }
 
 func GetExternal(c *gin.Context) {
-	appG := app.Gin{C:c}
-	ip,err := util.GetExternal()
+	appG := app.Gin{C: c}
+	ip, err := util.GetExternal()
 	if err != nil {
 		appG.Response(http.StatusOK, e.ERROR, "get external ip err")
 		return
@@ -258,8 +257,8 @@ func GetExternal(c *gin.Context) {
 }
 
 func GetServerStatus(c *gin.Context) {
-	appG := app.Gin{C:c}
-	disks,err := pai.MonitorServer()
+	appG := app.Gin{C: c}
+	disks, err := pai.MonitorServer()
 	if err != nil {
 		appG.Response(http.StatusOK, e.ERROR, err)
 		return

routers/router.go

 package routers
 
 import (
-	"github.com/gin-gonic/gin"
 	_ "chain33-pai/docs"
 	"chain33-pai/routers/api/v1"
+	"github.com/gin-gonic/gin"
 	"net/http"
 )
 
@@ -15,58 +15,58 @@ func InitRouter() *gin.Engine {
 	r.Use(Cors())
 	apiv1 := r.Group("/pai")
 	//获取树莓派基本信息
-	apiv1.POST("/devdetail",v1.GetDevdetail)
+	apiv1.POST("/devdetail", v1.GetDevdetail)
 	//获取树莓派基本信息
-	apiv1.POST("/resetwallet",v1.ResetWallet)
+	apiv1.POST("/resetwallet", v1.ResetWallet)
 	//更新bityuan节点 下载替换 重启
-	apiv1.POST("/updatenode",v1.UpdateNodeNew)
+	apiv1.POST("/updatenode", v1.UpdateNodeNew)
 	//检查节点是否还在更新同步 节点6.4.0大版本更新可能需要十几个小时 故加此接口
-	apiv1.POST("/nodeupdate",v1.UpdateNodeStatus)
-	apiv1.POST("/devstatus",v1.GetDevstatus)
-	apiv1.POST("/updatedetail",v1.UpdateDetail)
-	apiv1.POST("/version",v1.Version)
-	apiv1.POST("/reset",v1.ResetNode)
-	apiv1.POST("/nodeinfo",v1.NodeInfo)
+	apiv1.POST("/nodeupdate", v1.UpdateNodeStatus)
+	apiv1.POST("/devstatus", v1.GetDevstatus)
+	apiv1.POST("/updatedetail", v1.UpdateDetail)
+	apiv1.POST("/version", v1.Version)
+	apiv1.POST("/reset", v1.ResetNode)
+	apiv1.POST("/nodeinfo", v1.NodeInfo)
 
 	//本程序版本
-	apiv1.POST("/paiversion",v1.GetPaiVersion)
+	apiv1.POST("/paiversion", v1.GetPaiVersion)
 	//本程序下载新版本
-	apiv1.POST("/updatepai",v1.UpdatePaiNew)
+	apiv1.POST("/updatepai", v1.UpdatePaiNew)
 	//获取下载进度
-	apiv1.POST("/dpercent",v1.GetDPercent)
+	apiv1.POST("/dpercent", v1.GetDPercent)
 	//获取外网ip
-	apiv1.POST("/external",v1.GetExternal)
+	apiv1.POST("/external", v1.GetExternal)
 	//服务器状态
-	apiv1.POST("/serverstatus",v1.GetServerStatus)
+	apiv1.POST("/serverstatus", v1.GetServerStatus)
 	//反馈信息
-	apiv1.POST("/feedback",v1.FeedBackWithoutSSH)
+	apiv1.POST("/feedback", v1.FeedBackWithoutSSH)
 	//反馈处理进度
-	apiv1.POST("/iscomplete",v1.FeedBackStatusWithoutSSH)
+	apiv1.POST("/iscomplete", v1.FeedBackStatusWithoutSSH)
 	//反馈信息
-	apiv1.POST("/feedback1",v1.FeedBack)
+	apiv1.POST("/feedback1", v1.FeedBack)
 	//反馈处理进度
-	apiv1.POST("/iscomplete1",v1.FeedBackStatus)
-	apiv1.POST("/escrowpassword",v1.EscrowPasswd)
+	apiv1.POST("/iscomplete1", v1.FeedBackStatus)
+	apiv1.POST("/escrowpassword", v1.EscrowPasswd)
 	//pai更新完成用户手动重启设备
 	//apiv1.POST("/isreboot",v1.IsReBoot)
 	//重启节点
-	apiv1.POST("/restartnode",v1.RestartNode)
+	apiv1.POST("/restartnode", v1.RestartNode)
 	//安全关闭节点，不会再重启  除非是重启树莓派
-	apiv1.POST("/closenode",v1.CloseNode)
+	apiv1.POST("/closenode", v1.CloseNode)
 	//sudo poweroff
-	apiv1.POST("/poweroff",v1.PoweroffPai)
+	apiv1.POST("/poweroff", v1.PoweroffPai)
 	//test
-	apiv1.POST("/test",v1.Test)
+	apiv1.POST("/test", v1.Test)
 	//回滚1000区块
-	apiv1.POST("/rollback",v1.Rollback)
+	apiv1.POST("/rollback", v1.Rollback)
 	//一键备份 40g
-	apiv1.POST("/nodebackup",v1.NodeBackup)
+	apiv1.POST("/nodebackup", v1.NodeBackup)
 	//一键恢复 针对不同步  并且 回滚多次还不同步的情况下拿最近的备份恢复
-	apiv1.POST("/noderecover",v1.NodeRecover)
+	apiv1.POST("/noderecover", v1.NodeRecover)
 	//删除备份
-	apiv1.POST("/delbackup",v1.DelBackup)
+	apiv1.POST("/delbackup", v1.DelBackup)
 	//是否备份
-	apiv1.POST("/isbackup",v1.CheckBackup)
+	apiv1.POST("/isbackup", v1.CheckBackup)
 	return r
 }
 

service/pai_service/pai.go

 package pai_service
 
 import (
-	"os/exec"
-	"io"
-	"strings"
 	"bufio"
+	"bytes"
 	"chain33-pai/pkg/chain33"
-	"github.com/33cn/chain33/types"
+	"chain33-pai/pkg/pai"
+	"chain33-pai/pkg/setting"
+	"encoding/json"
+	"errors"
 	log "github.com/33cn/chain33/common/log/log15"
-	"net/http"
-	"bytes"
+	"github.com/33cn/chain33/types"
+	"io"
 	"io/ioutil"
-	"encoding/json"
-	"chain33-pai/pkg/setting"
-	"chain33-pai/pkg/pai"
+	"net/http"
 	"os"
-	"errors"
+	"os/exec"
 	"strconv"
+	"strings"
 )
 
 var (
@@ -69,13 +69,13 @@ func (p *Pai) SetPaiEnv() error {
 	cmd.Stdout = &buf
 	cmd.Run()
 	arch := buf.String()
-	p.Arch = strings.Replace(arch,"\n","",-1)
+	p.Arch = strings.Replace(arch, "\n", "", -1)
 	return nil
 }
 
 func (p *Pai) GetBtyVersion() error {
 	client := &chain33.PaiClient{}
-	v,err := client.Version()
+	v, err := client.Version()
 	if err != nil {
 		p.Err = err.Error()
 		return err
@@ -91,12 +91,12 @@ func (p *Pai) GetConfig() bool {
 	if p.Serial != "" {
 		return true
 	}
-	config ,err := getPaiConfig("cat","/proc/cpuinfo")
+	config, err := getPaiConfig("cat", "/proc/cpuinfo")
 	if err != nil {
 		p.Err = err.Error()
 		return false
 	}
-	if _,ok := config["serial"];ok {
+	if _, ok := config["serial"]; ok {
 		p.Serial = config["serial"]
 		p.Hardware = config["hardware"]
 		p.Revision = config["revision"]
@@ -107,14 +107,14 @@ func (p *Pai) GetConfig() bool {
 
 func (p *Pai) GetDevstatus() error {
 	client := &chain33.PaiClient{}
-	peerinfo,err := client.GetPeerInfo()
+	peerinfo, err := client.GetPeerInfo()
 	if err != nil {
-		tlog.Error("GetDevstatus peerinfo ","err",err)
+		tlog.Error("GetDevstatus peerinfo ", "err", err)
 		p.Err = err.Error()
 		return err
 	}
 
-	for _,v := range peerinfo.Peers {
+	for _, v := range peerinfo.Peers {
 		if p.LastHeight < v.Header.Height {
 			p.LastHeight = v.Header.Height
 		}
@@ -122,31 +122,31 @@ func (p *Pai) GetDevstatus() error {
 			p.LocalLastHeight = v.Header.Height
 		}
 	}
-	sync ,err := client.IsNtpClockSync()
+	sync, err := client.IsNtpClockSync()
 	if err != nil {
 		p.Err = err.Error()
-		tlog.Error("GetDevstatus IsNtpClockSync"," err",err)
+		tlog.Error("GetDevstatus IsNtpClockSync", " err", err)
 		return err
 	}
 	p.IsNtpSync = sync.IsOk
-	netinfo,err := client.GetNetInfo()
+	netinfo, err := client.GetNetInfo()
 	if err != nil {
 		p.Err = err.Error()
-		tlog.Error("GetDevstatus GetNetInfo"," err",err)
+		tlog.Error("GetDevstatus GetNetInfo", " err", err)
 		return err
 	}
 	p.NetInfo = netinfo
-	walletstatus,err := client.GetWalletStatus()
+	walletstatus, err := client.GetWalletStatus()
 	if err != nil {
 		p.Err = err.Error()
-		tlog.Error("GetDevstatus GetWalletStatus ","err",err)
+		tlog.Error("GetDevstatus GetWalletStatus ", "err", err)
 		return err
 	}
 	p.WalletStatus = walletstatus
 	return nil
 }
 
-func getPaiConfig(command string ,arg ...string) (config map[string]string,err error) {
+func getPaiConfig(command string, arg ...string) (config map[string]string, err error) {
 	//获取操作系统版本信息
 
 	list := make(map[string]string, 0)
@@ -154,20 +154,20 @@ func getPaiConfig(command string ,arg ...string) (config map[string]string,err e
 	stdout, err := cmd.StdoutPipe()
 	//tlog.Info(stdout)
 	if err != nil {
-		tlog.Info("getPaiConfig",err)
-		return nil,err
+		tlog.Info("getPaiConfig", err)
+		return nil, err
 	}
 	defer stdout.Close()
 	if err := cmd.Start(); err != nil {
-		tlog.Info("getPaiConfig",err)
-		return nil,err
+		tlog.Info("getPaiConfig", err)
+		return nil, err
 	}
 	rd := bufio.NewReader(stdout)
 	for {
 		line, err := rd.ReadString('\n')
-		if err!=nil || io.EOF==err{
+		if err != nil || io.EOF == err {
 			break
-		}else{
+		} else {
 			//tlog.Info("line", line)
 			l := strings.Split(line, ":")
 
@@ -188,17 +188,17 @@ func getPaiConfig(command string ,arg ...string) (config map[string]string,err e
 	return list, nil
 }
 
-func (p *Pai) GetPaiLatestVersion(t int32) (string,error) {
+func (p *Pai) GetPaiLatestVersion(t int32) (string, error) {
 	data := make(map[string]interface{})
 	data["type"] = t
 	bytesData, _ := json.Marshal(data)
-	resp, err := http.Post(setting.Chain33Pai.VersionUrl,"application/json", bytes.NewReader(bytesData))
+	resp, err := http.Post(setting.Chain33Pai.VersionUrl, "application/json", bytes.NewReader(bytesData))
 	if err != nil {
-		return "",err
+		return "", err
 	}
 	body, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return "",err
+		return "", err
 	}
 	type res struct {
 		Code int64
@@ -206,15 +206,15 @@ func (p *Pai) GetPaiLatestVersion(t int32) (string,error) {
 		Data string
 	}
 	var r res
-	err = json.Unmarshal(body,&r)
+	err = json.Unmarshal(body, &r)
 	if err != nil {
-		return "",err
+		return "", err
 	}
-	return r.Data,nil
+	return r.Data, nil
 }
 
 func (p *Pai) GetDiskUseage() error {
-	disks,err := pai.MonitorServer()
+	disks, err := pai.MonitorServer()
 	if err != nil {
 		return err
 	}
@@ -227,14 +227,14 @@ func (p *Pai) GetDiskUseage() error {
 func (p *Pai) CheckBackup() error {
 	path := pai.FindAbsPath("wallet-bty")
 	if path == "" {
-		tlog.Error("IsBackup","path","node not exists")
+		tlog.Error("IsBackup", "path", "node not exists")
 		//p.IsBackup = false
 		return errors.New("node not exists")
 	}
 	backupPath := path + "/datadir_backup"
-	if _,err := os.Stat(backupPath);err != nil {
+	if _, err := os.Stat(backupPath); err != nil {
 		if os.IsNotExist(err) {
-			tlog.Error("backup file not exists","err",backupPath)
+			tlog.Error("backup file not exists", "err", backupPath)
 			p.IsBackup = false
 			return errors.New("backup file not exists")
 		}
@@ -245,15 +245,15 @@ func (p *Pai) CheckBackup() error {
 
 func (p *Pai) GetTemp() error {
 	var b bytes.Buffer
-	cmd := exec.Command("cat","/sys/class/thermal/thermal_zone0/temp")
+	cmd := exec.Command("cat", "/sys/class/thermal/thermal_zone0/temp")
 	cmd.Stdout = &b
 	err := cmd.Run()
 	if err != nil {
 		return err
 	}
-	list := strings.Split(b.String(),"\n")
+	list := strings.Split(b.String(), "\n")
 	if list[0] != "" {
-		temp,_ := strconv.Atoi(list[0])
+		temp, _ := strconv.Atoi(list[0])
 		p.Temp = int64(temp)
 	}
 	return nil