nodeMonitor/internal/controller/Node.go

package controller

import (
	"fmt"
	"github.com/gogf/gf/v2/errors/gcode"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gcron"
	"github.com/gogf/gf/v2/os/glog"
	"golang.org/x/net/context"
	v1 "nodeMonitor/api/v1"
	"nodeMonitor/internal/model"
	"nodeMonitor/internal/service"
	"nodeMonitor/internal/task"
	"time"
)

var Node = sNode{}

type sNode struct {
}

func (c *sNode) Add(ctx context.Context, req *v1.NodeReq) (res *v1.NodeRes, err error) {
	//res = new(v1.NodeRes)
	exist, err := service.Node().IsExist(ctx, req.Host)
	if err != nil {
		return
	}
	if !exist {
		err = gerror.NewCode(gcode.New(401, "", nil), "数据已经存在")
		return
	}

	err = service.Node().Create(ctx, model.NodeCreateInput{
		Name:     req.Name,
		Host:     req.Host,
		Port:     req.Port,
		Url:      req.Url,
		PingType: req.PingType,
	})

	server, err := service.Node().FindServer(ctx, req.Host)

	err = service.NodeConfig().Create(ctx, model.NodeConfigAndEditCreateInput{
		ServerId: server.Id,
		SshCom:   req.Sshcommand,
		SshPass:  req.Sshpassword,
		SshUser:  req.Sshusername,
	})

	return
}

func (c *sNode) Del(ctx context.Context, req *v1.NodeDelReq) (res *v1.NodeDelRes, err error) {

	err = service.Node().Del(ctx, model.NodeDelInput{
		Id: req.Id,
	})

	err = service.NodeConfig().Delete(ctx, req.Id)

	return
}

func (c *sNode) Edit(ctx context.Context, req *v1.NodeEditReq) (res *v1.NodeEditRes, err error) {
	err = service.Node().UpdateNode(ctx, model.NodeEditInput{
		Id:         req.Id,
		Name:       req.Name,
		Host:       req.Host,
		Port:       req.Port,
		Url:        req.Url,
		UrlRecover: req.UrlRecover,
		PingType:   req.PingType,
		UrlStatus:  req.UrlStatus,
		IsNotice:   req.IsNotice,
	})

	err = service.NodeConfig().Edit(ctx, model.NodeConfigAndEditCreateInput{
		ServerId: req.Id,
		SshCom:   req.Sshcommand,
		SshPass:  req.Sshpassword,
		SshUser:  req.Sshusername,
	})
	return
}

func (c *sNode) All(ctx context.Context, req *v1.NodeAllReq) (res *v1.NodeALlRes, err error) {
	res = new(v1.NodeALlRes)
	res.NodeList, err = service.NodeConfig().GetAll(ctx)
	return
}

func (c *sNode) NodeStatus(ctx context.Context, req *v1.NodeStatusReq) (res *v1.NodeStatusRes, err error) {
	res = new(v1.NodeStatusRes)
	res.NodeItme, err = service.Node().GetNodePingStatus(ctx)
	return
}

func (c *sNode) Start(ctx context.Context, req *v1.NodeCronStartReq) (res *v1.NodeCronStartRes, err error) {
	res = new(v1.NodeCronStartRes)
	StartTime := req.StartTime

	taskName, err := g.Cfg().Get(ctx, "node.taskName")
	if err != nil {
		glog.Debug(ctx, err.Error())
		return
	}

	search := gcron.Search(taskName.String())
	if search != nil {
		gcron.Stop(taskName.String())
		gcron.Start(taskName.String())
		res.RetEntry = gcron.Entries()
		res.RetCronCount = gcron.Size()
		res.Status = true
		glog.Debug(ctx, "task -- ", gcron.Size())
	} else {
		s := fmt.Sprintf("*/%d * * * * *", StartTime)
		_, err = gcron.AddSingleton(ctx, s, func(ctx context.Context) {
			taskStatusTime, err := g.Cfg().Get(ctx, "node.taskStatusTime")
			if err != nil {
				glog.Error(ctx, err.Error())
				return
			}

			s := fmt.Sprintf("0 */%d * * * *", taskStatusTime.Int())
			t, err := task.GetCronNextTime(s, time.Now())
			if err != nil {
				glog.Error(ctx, err.Error())
				return
			}
			go task.PingStatus(ctx, t)
		}, taskName.String())
		res.RetEntry = gcron.Entries()
		res.RetCronCount = gcron.Size()
		res.Status = true
	}

	//taskStatusName, err := g.Cfg().Get(ctx, "node.ping_status_task")
	//if err != nil {
	//	glog.Debug(ctx, err.Error())
	//	return
	//}
	//search_status := gcron.Search(taskStatusName.String())
	//if search_status != nil {
	//	gcron.Stop(taskStatusName.String())
	//	gcron.Start(taskStatusName.String())
	//	glog.Debug(ctx, "task -- ", gcron.Size())
	//	res.RetEntry = gcron.Entries()
	//	res.RetCronCount = gcron.Size()
	//	res.Status = true
	//} else {
	//	s := fmt.Sprintf("*/%d * * * * *", 120)
	//	_, err = gcron.AddSingleton(ctx, s, func(ctx context.Context) {
	//		go task.PingStatus(ctx)
	//	}, taskStatusName.String())
	//	res.RetEntry = gcron.Entries()
	//	res.RetCronCount = gcron.Size()
	//	res.Status = true
	//
	//}

	return
}

func (c *sNode) Stop(ctx context.Context, req *v1.NodeCronStopReq) (res *v1.NodeCronStopRes, err error) {
	res = new(v1.NodeCronStopRes)
	remove := req.Remove
	taskName, err := g.Cfg().Get(ctx, "node.taskName")
	if err != nil {
		glog.Debug(ctx, err.Error())
		return
	}

	//taskStatusName, err := g.Cfg().Get(ctx, "node.ping_status_task")
	//if err != nil {
	//	glog.Debug(ctx, err.Error())
	//	return
	//}

	gcron.Stop(taskName.String())
	//gcron.Stop(taskStatusName.String())
	if remove {
		gcron.Remove(taskName.String())
		//gcron.Remove(taskStatusName.String())
	}

	search := gcron.Search(taskName.String())
	if search == nil {
		res.Status = false
	}
	//search_status := gcron.Search(taskStatusName.String())
	//if search_status == nil {
	//	res.Status = false
	//}
	res.RetCronCount = gcron.Size()

	return
}

func (c *sNode) Task(ctx context.Context, req *v1.NodeCronStatusReq) (res *v1.NodeCronStatusRes, err error) {
	res = new(v1.NodeCronStatusRes)
	res.RetEntry = gcron.Entries()
	res.RetCronCount = gcron.Size()
	return
}