waf-platform/EdgeAPI/internal/rpc/services/nameservers/service_ns.go

// Copyright 2021 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
//go:build plus

package nameservers

import (
	"context"
	"github.com/TeaOSLab/EdgeAPI/internal/db/models"
	"github.com/TeaOSLab/EdgeAPI/internal/db/models/nameservers"
	"github.com/TeaOSLab/EdgeAPI/internal/rpc/services"
	"github.com/TeaOSLab/EdgeCommon/pkg/dnsconfigs"
	"github.com/TeaOSLab/EdgeCommon/pkg/nodeconfigs"
	"github.com/TeaOSLab/EdgeCommon/pkg/rpc/pb"
	timeutil "github.com/iwind/TeaGo/utils/time"
	"time"
)

// NSService 域名服务
type NSService struct {
	services.BaseService
}

// ComposeNSBoard 组合看板数据
func (this *NSService) ComposeNSBoard(ctx context.Context, req *pb.ComposeNSBoardRequest) (*pb.ComposeNSBoardResponse, error) {
	_, err := this.ValidateAdmin(ctx)
	if err != nil {
		return nil, err
	}

	var tx = this.NullTx()
	var result = &pb.ComposeNSBoardResponse{}

	// 域名
	countDomains, err := nameservers.SharedNSDomainDAO.CountAllEnabledDomains(tx, 0, 0, 0, dnsconfigs.NSDomainStatusVerified, "")
	if err != nil {
		return nil, err
	}
	result.CountNSDomains = countDomains

	// 记录
	countRecords, err := nameservers.SharedNSRecordDAO.CountAllEnabledRecords(tx)
	if err != nil {
		return nil, err
	}
	result.CountNSRecords = countRecords

	// 集群数
	countClusters, err := models.SharedNSClusterDAO.CountAllEnabledClusters(tx)
	if err != nil {
		return nil, err
	}
	result.CountNSClusters = countClusters

	// 节点数
	countNodes, err := models.SharedNSNodeDAO.CountAllEnabledNodes(tx)
	if err != nil {
		return nil, err
	}
	result.CountNSNodes = countNodes

	// 离线节点数
	countOfflineNodes, err := models.SharedNSNodeDAO.CountAllOfflineNodes(tx)
	if err != nil {
		return nil, err
	}
	result.CountOfflineNSNodes = countOfflineNodes

	// 按小时统计
	var hourFrom = timeutil.Format("YmdH", time.Now().Add(-23*time.Hour))
	var hourTo = timeutil.Format("YmdH")
	hourlyStats, err := nameservers.SharedNSRecordHourlyStatDAO.FindHourlyStats(tx, hourFrom, hourTo)
	if err != nil {
		return nil, err
	}
	for _, stat := range hourlyStats {
		result.HourlyTrafficStats = append(result.HourlyTrafficStats, &pb.ComposeNSBoardResponse_HourlyTrafficStat{
			Hour:          stat.Hour,
			Bytes:         int64(stat.Bytes),
			CountRequests: int64(stat.CountRequests),
		})
	}

	// 按天统计
	var dayFrom = timeutil.Format("Ymd", time.Now().AddDate(0, 0, -14))
	var dayTo = timeutil.Format("Ymd")
	dailyStats, err := nameservers.SharedNSRecordHourlyStatDAO.FindDailyStats(tx, dayFrom, dayTo)
	if err != nil {
		return nil, err
	}
	for _, stat := range dailyStats {
		result.DailyTrafficStats = append(result.DailyTrafficStats, &pb.ComposeNSBoardResponse_DailyTrafficStat{
			Day:           stat.Day,
			Bytes:         int64(stat.Bytes),
			CountRequests: int64(stat.CountRequests),
		})
	}

	// 域名排行
	topDomainStats, err := nameservers.SharedNSRecordHourlyStatDAO.ListTopDomains(tx, 0, hourFrom, hourTo, 10)
	if err != nil {
		return nil, err
	}
	for _, stat := range topDomainStats {
		domainName, err := nameservers.SharedNSDomainDAO.FindNSDomainName(tx, int64(stat.DomainId))
		if err != nil {
			return nil, err
		}
		if len(domainName) == 0 {
			continue
		}
		result.TopNSDomainStats = append(result.TopNSDomainStats, &pb.ComposeNSBoardResponse_DomainStat{
			NsDomainId:    int64(stat.DomainId),
			NsDomainName:  domainName,
			CountRequests: int64(stat.CountRequests),
			Bytes:         int64(stat.Bytes),
		})
	}

	// 节点排行
	topNodeStats, err := nameservers.SharedNSRecordHourlyStatDAO.ListTopNodes(tx, hourFrom, hourTo, 10)
	if err != nil {
		return nil, err
	}
	for _, stat := range topNodeStats {
		nodeName, err := models.SharedNSNodeDAO.FindEnabledNSNodeName(tx, int64(stat.NodeId))
		if err != nil {
			return nil, err
		}
		if len(nodeName) == 0 {
			continue
		}
		result.TopNSNodeStats = append(result.TopNSNodeStats, &pb.ComposeNSBoardResponse_NodeStat{
			NsClusterId:   int64(stat.ClusterId),
			NsNodeId:      int64(stat.NodeId),
			NsNodeName:    nodeName,
			CountRequests: int64(stat.CountRequests),
			Bytes:         int64(stat.Bytes),
		})
	}

	// CPU、内存、负载
	cpuValues, err := models.SharedNodeValueDAO.ListValuesForNSNodes(tx, nodeconfigs.NodeValueItemCPU, "usage", nodeconfigs.NodeValueRangeMinute)
	if err != nil {
		return nil, err
	}
	for _, v := range cpuValues {
		result.CpuNodeValues = append(result.CpuNodeValues, &pb.NodeValue{
			ValueJSON: v.Value,
			CreatedAt: int64(v.CreatedAt),
		})
	}

	memoryValues, err := models.SharedNodeValueDAO.ListValuesForNSNodes(tx, nodeconfigs.NodeValueItemMemory, "usage", nodeconfigs.NodeValueRangeMinute)
	if err != nil {
		return nil, err
	}
	for _, v := range memoryValues {
		result.MemoryNodeValues = append(result.MemoryNodeValues, &pb.NodeValue{
			ValueJSON: v.Value,
			CreatedAt: int64(v.CreatedAt),
		})
	}

	loadValues, err := models.SharedNodeValueDAO.ListValuesForNSNodes(tx, nodeconfigs.NodeValueItemLoad, "load1m", nodeconfigs.NodeValueRangeMinute)
	if err != nil {
		return nil, err
	}
	for _, v := range loadValues {
		result.LoadNodeValues = append(result.LoadNodeValues, &pb.NodeValue{
			ValueJSON: v.Value,
			CreatedAt: int64(v.CreatedAt),
		})
	}

	return result, nil
}

// ComposeNSUserBoard 组合用户看板数据
func (this *NSService) ComposeNSUserBoard(ctx context.Context, req *pb.ComposeNSUserBoardRequest) (*pb.ComposeNSUserBoardResponse, error) {
	_, userId, err := this.ValidateAdminAndUser(ctx, true)
	if err != nil {
		return nil, err
	}

	if userId > 0 {
		req.UserId = userId
	}

	var result = &pb.ComposeNSUserBoardResponse{}

	var tx = this.NullTx()
	countDomains, err := nameservers.SharedNSDomainDAO.CountAllEnabledDomains(tx, 0, req.UserId, 0, "", "")
	if err != nil {
		return nil, err
	}
	result.CountNSDomains = countDomains

	countRecords, err := nameservers.SharedNSRecordDAO.CountAllUserRecords(tx, req.UserId)
	if err != nil {
		return nil, err
	}
	result.CountNSRecords = countRecords

	countRoutes, err := nameservers.SharedNSRouteDAO.CountAllEnabledRoutes(tx, 0, 0, req.UserId)
	if err != nil {
		return nil, err
	}
	result.CountNSRoutes = countRoutes

	// 用户套餐
	userPlan, err := nameservers.SharedNSUserPlanDAO.FindUserPlan(tx, req.UserId)
	if err != nil {
		return nil, err
	}
	if userPlan != nil {
		if userPlan.PlanId > 0 && userPlan.DayTo >= timeutil.Format("Ymd") {
			plan, err := nameservers.SharedNSPlanDAO.FindEnabledNSPlan(tx, int64(userPlan.PlanId))
			if err != nil {
				return nil, err
			}
			if plan != nil && plan.IsOn {
				result.NsUserPlan = &pb.NSUserPlan{
					Id:         int64(userPlan.Id),
					NsPlanId:   int64(userPlan.PlanId),
					DayFrom:    userPlan.DayFrom,
					DayTo:      userPlan.DayTo,
					PeriodUnit: userPlan.PeriodUnit,
					NsPlan: &pb.NSPlan{
						Id:   int64(plan.Id),
						Name: plan.Name,
						IsOn: plan.IsOn,
					},
					User: nil,
				}
			}
		}
	}

	// 域名排行
	var hourFrom = timeutil.Format("YmdH", time.Now().Add(-23*time.Hour))
	var hourTo = timeutil.Format("YmdH")
	topDomainStats, err := nameservers.SharedNSRecordHourlyStatDAO.ListTopDomains(tx, userId, hourFrom, hourTo, 10)
	if err != nil {
		return nil, err
	}
	for _, stat := range topDomainStats {
		domainName, err := nameservers.SharedNSDomainDAO.FindNSDomainName(tx, int64(stat.DomainId))
		if err != nil {
			return nil, err
		}
		if len(domainName) == 0 {
			continue
		}
		result.TopNSDomainStats = append(result.TopNSDomainStats, &pb.ComposeNSUserBoardResponse_DomainStat{
			NsDomainId:    int64(stat.DomainId),
			NsDomainName:  domainName,
			CountRequests: int64(stat.CountRequests),
			Bytes:         int64(stat.Bytes),
		})
	}

	return result, nil
}