阶段性提交

internal/rpc/services/service_admin.go

@@ -2,31 +2,24 @@ package services
 
 import (
 	"context"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	teaconst "github.com/TeaOSLab/EdgeAPI/internal/const"
 	"github.com/TeaOSLab/EdgeAPI/internal/db/models"
-	"github.com/TeaOSLab/EdgeAPI/internal/encrypt"
 	"github.com/TeaOSLab/EdgeAPI/internal/rpc/pb"
+	rpcutils "github.com/TeaOSLab/EdgeAPI/internal/rpc/utils"
 	"github.com/TeaOSLab/EdgeAPI/internal/utils"
-	"github.com/iwind/TeaGo/maps"
-	"google.golang.org/grpc/metadata"
-	"time"
 )
 
 type AdminService struct {
 	debug bool
 }
 
-func (this *AdminService) Login(ctx context.Context, req *pb.AdminLoginRequest) (*pb.AdminLoginResponse, error) {
-	_, err := this.validateRequest(ctx)
+func (this *AdminService) LoginAdmin(ctx context.Context, req *pb.LoginAdminRequest) (*pb.LoginAdminResponse, error) {
+	_, _, err := rpcutils.ValidateRequest(ctx)
 	if err != nil {
 		return nil, err
 	}
 
 	if len(req.Username) == 0 || len(req.Password) == 0 {
-		return &pb.AdminLoginResponse{
+		return &pb.LoginAdminResponse{
 			AdminId: 0,
 			IsOk:    false,
 			Message: "请输入正确的用户名密码",
@@ -40,38 +33,38 @@ func (this *AdminService) Login(ctx context.Context, req *pb.AdminLoginRequest)
 	}
 
 	if adminId <= 0 {
-		return &pb.AdminLoginResponse{
+		return &pb.LoginAdminResponse{
 			AdminId: 0,
 			IsOk:    false,
 			Message: "请输入正确的用户名密码",
 		}, nil
 	}
 
-	return &pb.AdminLoginResponse{
+	return &pb.LoginAdminResponse{
 		AdminId: int64(adminId),
 		IsOk:    true,
 	}, nil
 }
 
-func (this *AdminService) CreateLog(ctx context.Context, req *pb.AdminCreateLogRequest) (*pb.AdminCreateLogResponse, error) {
-	adminId, err := this.validateAdminRequest(ctx)
+func (this *AdminService) CreateAdminLog(ctx context.Context, req *pb.CreateAdminLogRequest) (*pb.CreateAdminLogResponse, error) {
+	_, userId, err := rpcutils.ValidateRequest(ctx, rpcutils.UserTypeAdmin)
 	if err != nil {
 		return nil, err
 	}
-	err = models.SharedLogDAO.CreateAdminLog(adminId, req.Level, req.Description, req.Action, req.Ip)
-	return &pb.AdminCreateLogResponse{
+	err = models.SharedLogDAO.CreateAdminLog(userId, req.Level, req.Description, req.Action, req.Ip)
+	return &pb.CreateAdminLogResponse{
 		IsOk: err != nil,
 	}, err
 }
 
-func (this *AdminService) CheckAdminExists(ctx context.Context, req *pb.AdminCheckAdminExistsRequest) (*pb.AdminCheckAdminExistsResponse, error) {
-	_, err := this.validateRequest(ctx)
+func (this *AdminService) CheckAdminExists(ctx context.Context, req *pb.CheckAdminExistsRequest) (*pb.CheckAdminExistsResponse, error) {
+	_, _, err := rpcutils.ValidateRequest(ctx, rpcutils.UserTypeAdmin)
 	if err != nil {
 		return nil, err
 	}
 
 	if req.AdminId <= 0 {
-		return &pb.AdminCheckAdminExistsResponse{
+		return &pb.CheckAdminExistsResponse{
 			IsOk: false,
 		}, nil
 	}
@@ -81,13 +74,13 @@ func (this *AdminService) CheckAdminExists(ctx context.Context, req *pb.AdminChe
 		return nil, err
 	}
 
-	return &pb.AdminCheckAdminExistsResponse{
+	return &pb.CheckAdminExistsResponse{
 		IsOk: ok,
 	}, nil
 }
 
-func (this *AdminService) FindAdminFullname(ctx context.Context, req *pb.AdminFindAdminNameRequest) (*pb.AdminFindAdminNameResponse, error) {
-	_, err := this.validateRequest(ctx)
+func (this *AdminService) FindAdminFullname(ctx context.Context, req *pb.FindAdminNameRequest) (*pb.FindAdminNameResponse, error) {
+	_, _, err := rpcutils.ValidateRequest(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -98,173 +91,7 @@ func (this *AdminService) FindAdminFullname(ctx context.Context, req *pb.AdminFi
 		return nil, err
 	}
 
-	return &pb.AdminFindAdminNameResponse{
+	return &pb.FindAdminNameResponse{
 		Fullname: fullname,
 	}, nil
-}
-
-func (this *AdminService) FindAllEnabledClusters(ctx context.Context, req *pb.AdminFindAllEnabledClustersRequest) (*pb.AdminFindAllEnabledClustersResponse, error) {
-	_ = req
-
-	_, err := this.validateAdminRequest(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	clusters, err := models.SharedNodeClusterDAO.FindAllEnableClusters()
-	if err != nil {
-		return nil, err
-	}
-
-	result := []*pb.Cluster{}
-	for _, cluster := range clusters {
-		result = append(result, &pb.Cluster{
-			Id:        int64(cluster.Id),
-			Name:      cluster.Name,
-			CreatedAt: int64(cluster.CreatedAt),
-		})
-	}
-
-	return &pb.AdminFindAllEnabledClustersResponse{
-		Clusters: result,
-	}, nil
-}
-
-func (this *AdminService) CreateNode(ctx context.Context, req *pb.AdminCreateNodeRequest) (*pb.AdminCreateNodeResponse, error) {
-	_, err := this.validateAdminRequest(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	nodeId, err := models.SharedNodeDAO.CreateNode(req.Name, int(req.ClusterId))
-	if err != nil {
-		return nil, err
-	}
-
-	return &pb.AdminCreateNodeResponse{
-		NodeId: int64(nodeId),
-	}, nil
-}
-
-func (this *AdminService) CountAllEnabledNodes(ctx context.Context, req *pb.AdminCountAllEnabledNodesRequest) (*pb.AdminCountAllEnabledNodesResponse, error) {
-	_, err := this.validateAdminRequest(ctx)
-	if err != nil {
-		return nil, err
-	}
-	count, err := models.SharedNodeDAO.CountAllEnabledNodes()
-	if err != nil {
-		return nil, err
-	}
-
-	return &pb.AdminCountAllEnabledNodesResponse{Count: count}, nil
-}
-
-func (this *AdminService) ListEnabledNodes(ctx context.Context, req *pb.AdminListEnabledNodesRequest) (*pb.AdminListEnabledNodesResponse, error) {
-	_, err := this.validateAdminRequest(ctx)
-	if err != nil {
-		return nil, err
-	}
-	nodes, err := models.SharedNodeDAO.ListEnabledNodes(req.Offset, req.Size)
-	if err != nil {
-		return nil, err
-	}
-	result := []*pb.Node{}
-	for _, node := range nodes {
-		// 集群信息
-		clusterName, err := models.SharedNodeClusterDAO.FindNodeClusterName(int64(node.ClusterId))
-		if err != nil {
-			return nil, err
-		}
-
-		result = append(result, &pb.Node{
-			Id:   int64(node.Id),
-			Name: node.Name,
-			Cluster: &pb.Cluster{
-				Id:   int64(node.ClusterId),
-				Name: clusterName,
-			},
-		})
-	}
-
-	return &pb.AdminListEnabledNodesResponse{
-		Nodes: result,
-	}, nil
-}
-
-func (this *AdminService) validateRequest(ctx context.Context) (adminId int, err error) {
-	var md metadata.MD
-	var ok bool
-	if this.debug {
-		md, ok = metadata.FromOutgoingContext(ctx)
-	} else {
-		md, ok = metadata.FromIncomingContext(ctx)
-	}
-	if !ok {
-		return 0, errors.New("context: need 'nodeId'")
-	}
-	nodeIds := md.Get("nodeid")
-	if len(nodeIds) == 0 || len(nodeIds[0]) == 0 {
-		return 0, errors.New("context: need 'nodeId'")
-	}
-	nodeId := nodeIds[0]
-
-	// 获取Node信息
-	apiToken, err := models.SharedApiTokenDAO.FindEnabledTokenWithNode(nodeId)
-	if err != nil {
-		utils.PrintError(err)
-		return 0, err
-	}
-	if apiToken == nil {
-		return 0, errors.New("can not find token from node id: " + err.Error())
-	}
-
-	tokens := md.Get("token")
-	if len(tokens) == 0 || len(tokens[0]) == 0 {
-		return 0, errors.New("context: need 'token'")
-	}
-	token := tokens[0]
-
-	data, err := base64.StdEncoding.DecodeString(token)
-	if err != nil {
-		return 0, err
-	}
-
-	method, err := encrypt.NewMethodInstance(teaconst.EncryptMethod, apiToken.Secret, nodeId)
-	if err != nil {
-		utils.PrintError(err)
-		return 0, err
-	}
-	data, err = method.Decrypt(data)
-	if err != nil {
-		return 0, err
-	}
-	if len(data) == 0 {
-		return 0, errors.New("invalid token")
-	}
-
-	m := maps.Map{}
-	err = json.Unmarshal(data, &m)
-	if err != nil {
-		return 0, errors.New("decode token error: " + err.Error())
-	}
-
-	timestamp := m.GetInt64("timestamp")
-	if time.Now().Unix()-timestamp > 600 {
-		// 请求超过10分钟认为超时
-		return 0, errors.New("authenticate timeout")
-	}
-
-	adminId = m.GetInt("adminId")
-	return
-}
-
-func (this *AdminService) validateAdminRequest(ctx context.Context) (adminId int, err error) {
-	adminId, err = this.validateRequest(ctx)
-	if err != nil {
-		return 0, err
-	}
-	if adminId <= 0 {
-		return 0, errors.New("invalid admin id")
-	}
-	return
-}
+}

internal/rpc/services/service_dns.go

@@ -1,4 +0,0 @@
-package services
-
-type DNSService struct {
-}

internal/rpc/services/service_log.go

@@ -1,4 +0,0 @@
-package services
-
-type LogService struct {
-}

internal/rpc/services/service_monitor.go

@@ -1,4 +0,0 @@
-package services
-
-type MonitorService struct {
-}

internal/rpc/services/service_node.go

@@ -2,16 +2,71 @@ package services
 
 import (
 	"context"
+	"github.com/TeaOSLab/EdgeAPI/internal/db/models"
 	"github.com/TeaOSLab/EdgeAPI/internal/rpc/pb"
-	"github.com/iwind/TeaGo/logs"
+	rpcutils "github.com/TeaOSLab/EdgeAPI/internal/rpc/utils"
 )
 
 type NodeService struct {
 }
 
-func (this *NodeService) Config(ctx context.Context, req *pb.ConfigRequest) (*pb.ConfigResponse, error) {
-	logs.Println("you called me")
-	return &pb.ConfigResponse{
-		Id: req.NodeId,
+func (this *NodeService) CreateNode(ctx context.Context, req *pb.CreateNodeRequest) (*pb.CreateNodeResponse, error) {
+	_, _, err := rpcutils.ValidateRequest(ctx, rpcutils.UserTypeAdmin)
+	if err != nil {
+		return nil, err
+	}
+
+	nodeId, err := models.SharedNodeDAO.CreateNode(req.Name, int(req.ClusterId))
+	if err != nil {
+		return nil, err
+	}
+
+	return &pb.CreateNodeResponse{
+		NodeId: int64(nodeId),
+	}, nil
+}
+
+func (this *NodeService) CountAllEnabledNodes(ctx context.Context, req *pb.CountAllEnabledNodesRequest) (*pb.CountAllEnabledNodesResponse, error) {
+	_, _, err := rpcutils.ValidateRequest(ctx, rpcutils.UserTypeAdmin)
+	if err != nil {
+		return nil, err
+	}
+	count, err := models.SharedNodeDAO.CountAllEnabledNodes()
+	if err != nil {
+		return nil, err
+	}
+
+	return &pb.CountAllEnabledNodesResponse{Count: count}, nil
+}
+
+func (this *NodeService) ListEnabledNodes(ctx context.Context, req *pb.ListEnabledNodesRequest) (*pb.ListEnabledNodesResponse, error) {
+	_, _, err := rpcutils.ValidateRequest(ctx, rpcutils.UserTypeAdmin)
+	if err != nil {
+		return nil, err
+	}
+	nodes, err := models.SharedNodeDAO.ListEnabledNodes(req.Offset, req.Size)
+	if err != nil {
+		return nil, err
+	}
+	result := []*pb.Node{}
+	for _, node := range nodes {
+		// 集群信息
+		clusterName, err := models.SharedNodeClusterDAO.FindNodeClusterName(int64(node.ClusterId))
+		if err != nil {
+			return nil, err
+		}
+
+		result = append(result, &pb.Node{
+			Id:   int64(node.Id),
+			Name: node.Name,
+			Cluster: &pb.NodeCluster{
+				Id:   int64(node.ClusterId),
+				Name: clusterName,
+			},
+		})
+	}
+
+	return &pb.ListEnabledNodesResponse{
+		Nodes: result,
 	}, nil
 }

internal/rpc/services/service_node_cluster.go

@@ -0,0 +1,38 @@
+package services
+
+import (
+	"context"
+	"github.com/TeaOSLab/EdgeAPI/internal/db/models"
+	"github.com/TeaOSLab/EdgeAPI/internal/rpc/pb"
+	rpcutils "github.com/TeaOSLab/EdgeAPI/internal/rpc/utils"
+)
+
+type NodeClusterService struct {
+}
+
+func (this *NodeClusterService) FindAllEnabledClusters(ctx context.Context, req *pb.FindAllEnabledNodeClustersRequest) (*pb.FindAllEnabledNodeClustersResponse, error) {
+	_ = req
+
+	_, _, err := rpcutils.ValidateRequest(ctx, rpcutils.UserTypeAdmin)
+	if err != nil {
+		return nil, err
+	}
+
+	clusters, err := models.SharedNodeClusterDAO.FindAllEnableClusters()
+	if err != nil {
+		return nil, err
+	}
+
+	result := []*pb.NodeCluster{}
+	for _, cluster := range clusters {
+		result = append(result, &pb.NodeCluster{
+			Id:        int64(cluster.Id),
+			Name:      cluster.Name,
+			CreatedAt: int64(cluster.CreatedAt),
+		})
+	}
+
+	return &pb.FindAllEnabledNodeClustersResponse{
+		Clusters: result,
+	}, nil
+}

internal/rpc/services/service_node_grant.go

@@ -0,0 +1,89 @@
+package services
+
+import (
+	"context"
+	"errors"
+	"github.com/TeaOSLab/EdgeAPI/internal/db/models"
+	"github.com/TeaOSLab/EdgeAPI/internal/rpc/pb"
+	rpcutils "github.com/TeaOSLab/EdgeAPI/internal/rpc/utils"
+)
+
+type NodeGrantService struct {
+}
+
+func (this *NodeGrantService) CreateNodeGrant(ctx context.Context, req *pb.CreateNodeGrantRequest) (*pb.CreateNodeGrantResponse, error) {
+	_, _, err := rpcutils.ValidateRequest(ctx, rpcutils.UserTypeAdmin)
+	if err != nil {
+		return nil, err
+	}
+
+	grantId, err := models.SharedNodeGrantDAO.CreateGrant(req.Name, req.Method, req.Username, req.Password, req.PrivateKey, req.Description, req.NodeId)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.CreateNodeGrantResponse{
+		GrantId: grantId,
+	}, err
+}
+
+func (this *NodeGrantService) UpdateNodeGrant(ctx context.Context, req *pb.UpdateNodeGrantRequest) (*pb.UpdateNodeGrantResponse, error) {
+	_, _, err := rpcutils.ValidateRequest(ctx, rpcutils.UserTypeAdmin)
+	if err != nil {
+		return nil, err
+	}
+
+	if req.GrantId <= 0 {
+		return nil, errors.New("wrong grantId")
+	}
+
+	err = models.SharedNodeGrantDAO.UpdateGrant(req.GrantId, req.Name, req.Method, req.Username, req.Password, req.PrivateKey, req.Description, req.NodeId)
+	return &pb.UpdateNodeGrantResponse{}, err
+}
+
+func (this *NodeGrantService) DisableNodeGrant(ctx context.Context, req *pb.DisableNodeGrantRequest) (*pb.DisableNodeGrantResponse, error) {
+	_, _, err := rpcutils.ValidateRequest(ctx, rpcutils.UserTypeAdmin)
+	if err != nil {
+		return nil, err
+	}
+
+	err = models.SharedNodeGrantDAO.DisableNodeGrant(req.GrantId)
+	return &pb.DisableNodeGrantResponse{}, err
+}
+
+func (this *NodeGrantService) CountAllEnabledNodeGrants(ctx context.Context, req *pb.CountAllEnabledNodeGrantsRequest) (*pb.CountAllEnabledNodeGrantsResponse, error) {
+	_, _, err := rpcutils.ValidateRequest(ctx, rpcutils.UserTypeAdmin)
+	if err != nil {
+		return nil, err
+	}
+	count, err := models.SharedNodeGrantDAO.CountAllEnabledGrants()
+	if err != nil {
+		return nil, err
+	}
+	return &pb.CountAllEnabledNodeGrantsResponse{Count: count}, nil
+}
+
+func (this *NodeGrantService) ListEnabledNodeGrants(ctx context.Context, req *pb.ListEnabledNodeGrantsRequest) (*pb.ListEnabledNodeGrantsResponse, error) {
+	_, _, err := rpcutils.ValidateRequest(ctx, rpcutils.UserTypeAdmin)
+	if err != nil {
+		return nil, err
+	}
+	grants, err := models.SharedNodeGrantDAO.ListEnabledGrants(req.Offset, req.Size)
+	if err != nil {
+		return nil, err
+	}
+	result := []*pb.NodeGrant{}
+	for _, grant := range grants {
+		result = append(result, &pb.NodeGrant{
+			Id:          int64(grant.Id),
+			Name:        grant.Name,
+			Method:      grant.Method,
+			Password:    grant.Password,
+			Su:          grant.Su == 1,
+			PrivateKey:  grant.PrivateKey,
+			Description: grant.Description,
+			NodeId:      int64(grant.NodeId),
+		})
+	}
+
+	return &pb.ListEnabledNodeGrantsResponse{Grants: result}, nil
+}

internal/rpc/services/service_provider.go

@@ -1,4 +0,0 @@
-package services
-
-type ProviderService struct {
-}

internal/rpc/services/service_stat.go

@@ -1,4 +0,0 @@
-package services
-
-type StatService struct {
-}

internal/rpc/services/service_user.go

@@ -1,4 +0,0 @@
-package services
-
-type UserService struct {
-}

internal/rpc/services/servie_server.go

@@ -0,0 +1,68 @@
+package services
+
+import (
+	"context"
+	"github.com/TeaOSLab/EdgeAPI/internal/db/models"
+	"github.com/TeaOSLab/EdgeAPI/internal/rpc/pb"
+	rpcutils "github.com/TeaOSLab/EdgeAPI/internal/rpc/utils"
+)
+
+type ServerService struct {
+}
+
+func (this *ServerService) CreateServer(ctx context.Context, req *pb.CreateServerRequest) (*pb.CreateServerResponse, error) {
+	_, _, err := rpcutils.ValidateRequest(ctx, rpcutils.UserTypeAdmin)
+	if err != nil {
+		return nil, err
+	}
+	serverId, err := models.SharedServerDAO.CreateServer(req.AdminId, req.UserId, req.ClusterId, string(req.Config), string(req.IncludeNodesJSON), string(req.ExcludeNodesJSON))
+	if err != nil {
+		return nil, err
+	}
+	return &pb.CreateServerResponse{ServerId: serverId}, nil
+}
+
+func (this *ServerService) CountAllEnabledServers(ctx context.Context, req *pb.CountAllEnabledServersRequest) (*pb.CountAllEnabledServersResponse, error) {
+	_ = req
+	_, _, err := rpcutils.ValidateRequest(ctx)
+	if err != nil {
+		return nil, err
+	}
+	count, err := models.SharedServerDAO.CountAllEnabledServers()
+	if err != nil {
+		return nil, err
+	}
+
+	return &pb.CountAllEnabledServersResponse{Count: count}, nil
+}
+
+func (this *ServerService) ListEnabledServers(ctx context.Context, req *pb.ListEnabledServersRequest) (*pb.ListEnabledServersResponse, error) {
+	_, _, err := rpcutils.ValidateRequest(ctx, rpcutils.UserTypeAdmin)
+	if err != nil {
+		return nil, err
+	}
+	servers, err := models.SharedServerDAO.ListEnabledServers(req.Offset, req.Size)
+	if err != nil {
+		return nil, err
+	}
+	result := []*pb.Server{}
+	for _, server := range servers {
+		clusterName, err := models.SharedNodeClusterDAO.FindNodeClusterName(int64(server.ClusterId))
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, &pb.Server{
+			Id:           int64(server.Id),
+			Config:       []byte(server.Config),
+			IncludeNodes: []byte(server.IncludeNodes),
+			ExcludeNodes: []byte(server.ExcludeNodes),
+			CreatedAt:    int64(server.CreatedAt),
+			Cluster: &pb.NodeCluster{
+				Id:   int64(server.ClusterId),
+				Name: clusterName,
+			},
+		})
+	}
+
+	return &pb.ListEnabledServersResponse{Servers: result}, nil
+}