cdn-go/server/LoadBalancerCloudflareServer.go

package server

import (
	"cfTest/cloudflareApi/loadBalancer"
	"context"
	"github.com/cloudflare/cloudflare-go"
	"github.com/jinzhu/copier"
	"github.com/samber/lo"
	"log"
	"strings"
)

type LoadBalancerServer struct {
	loadBalancer.UnimplementedLoadBalancerCloudflareServer
}

func Go2ProtoLoadBalancer(goBalancer *cloudflare.LoadBalancer) (protoBalancer *loadBalancer.LoadBalancer) {
	protoBalancer = new(loadBalancer.LoadBalancer)
	err := copier.Copy(protoBalancer, goBalancer)
	if err != nil {
		return nil
	}
	protoBalancer.Id = goBalancer.ID

	return
}
func Proto2GoLoadBalancer(protoBalancer *loadBalancer.LoadBalancer) (goBalancer *cloudflare.LoadBalancer) {
	goBalancer = new(cloudflare.LoadBalancer)
	err := copier.Copy(goBalancer, protoBalancer)
	if err != nil {
		return nil
	}
	goBalancer.ID = protoBalancer.Id

	return
}

func (d LoadBalancerServer) List(ctx context.Context, request *loadBalancer.ListRequest) (*loadBalancer.LoadBalancerList, error) {
	if strings.HasPrefix(request.GetApiKey(), TOKEN_PREFIX) {
		api, err = cloudflare.NewWithAPIToken(request.GetApiKey()[TOKEN_PREFIX_LENGTH:])
	} else {
		api, err = cloudflare.New(request.GetApiKey(), request.GetApiEmail())
	}
	if err != nil {
		return nil, err
	}
	ctxAPI := context.Background()
	zoneIdentifier := cloudflare.ZoneIdentifier(request.ZoneId)
	listLoadBalancerParams := cloudflare.ListLoadBalancerParams{
		PaginationOptions: cloudflare.PaginationOptions{}}
	balancers, err := api.ListLoadBalancers(ctxAPI, zoneIdentifier, listLoadBalancerParams)
	log.Printf("Cloudflare ListLoadBalancers API balancers: %v err:%s", balancers, err)

	//balancers, err := api.ListLoadBalancers(ctxAPI, request.ZoneId)
	if err != nil {
		return nil, err
	}

	filterMap := lo.FilterMap[cloudflare.LoadBalancer, *loadBalancer.LoadBalancer](balancers, func(balancer cloudflare.LoadBalancer, _ int) (*loadBalancer.LoadBalancer, bool) {
		protoLoadBalancer := Go2ProtoLoadBalancer(&balancer)
		if protoLoadBalancer == nil {
			return nil, false
		}
		return protoLoadBalancer, true
	})
	return &loadBalancer.LoadBalancerList{LoadBalancers: filterMap}, nil
}

func (d LoadBalancerServer) Create(ctx context.Context, request *loadBalancer.LoadBalancerRequest) (*loadBalancer.LoadBalancer, error) {
	if strings.HasPrefix(request.GetApiKey(), TOKEN_PREFIX) {
		api, err = cloudflare.NewWithAPIToken(request.GetApiKey()[TOKEN_PREFIX_LENGTH:])
	} else {
		api, err = cloudflare.New(request.GetApiKey(), request.GetApiEmail())
	}
	if err != nil {
		return nil, err
	}

	ctxAPI := context.Background()
	zoneIdentifier := cloudflare.ZoneIdentifier(request.ZoneId)
	in := Proto2GoLoadBalancer(request.LoadBalancer)
	createLoadBalancerParams := cloudflare.CreateLoadBalancerParams{
		LoadBalancer: *in,
	}
	balancer, err := api.CreateLoadBalancer(ctxAPI, zoneIdentifier, createLoadBalancerParams)
	log.Printf("Cloudflare CreateLoadBalancer API balancer: %v err:%s", balancer, err)
	//balancer, err := api.CreateLoadBalancer(ctxAPI, request.ZoneId, *in)
	if err != nil {
		return nil, err
	}

	out := Go2ProtoLoadBalancer(&balancer)
	return out, nil
}

func (d LoadBalancerServer) Update(ctx context.Context, request *loadBalancer.LoadBalancerRequest) (*loadBalancer.LoadBalancer, error) {
	if strings.HasPrefix(request.GetApiKey(), TOKEN_PREFIX) {
		api, err = cloudflare.NewWithAPIToken(request.GetApiKey()[TOKEN_PREFIX_LENGTH:])
	} else {
		api, err = cloudflare.New(request.GetApiKey(), request.GetApiEmail())
	}
	if err != nil {
		return nil, err
	}

	ctxAPI := context.Background()

	in := Proto2GoLoadBalancer(request.LoadBalancer)
	zoneIdentifier := cloudflare.ZoneIdentifier(request.ZoneId)
	updateLoadBalancerParams := cloudflare.UpdateLoadBalancerParams{
		LoadBalancer: *in,
	}
	balancer, err := api.UpdateLoadBalancer(ctxAPI, zoneIdentifier, updateLoadBalancerParams)
	log.Printf("Cloudflare UpdateLoadBalancer API balancer: %v err:%s", balancer, err)
	//balancer, err := api.ModifyLoadBalancer(ctxAPI, request.ZoneId, *in)
	if err != nil {
		return nil, err
	}
	out := Go2ProtoLoadBalancer(&balancer)
	return out, nil
}

func (d LoadBalancerServer) Delete(ctx context.Context, request *loadBalancer.DeleteRequest) (*loadBalancer.Empty, error) {
	if strings.HasPrefix(request.GetApiKey(), TOKEN_PREFIX) {
		api, err = cloudflare.NewWithAPIToken(request.GetApiKey()[TOKEN_PREFIX_LENGTH:])
	} else {
		api, err = cloudflare.New(request.GetApiKey(), request.GetApiEmail())
	}
	if err != nil {
		return nil, err
	}

	ctxAPI := context.Background()
	zoneIdentifier := cloudflare.ZoneIdentifier(request.ZoneId)
	err = api.DeleteLoadBalancer(ctxAPI, zoneIdentifier, request.Id)
	log.Printf("Cloudflare DeleteLoadBalancer API err:%s", err)
	if err != nil {
		return nil, err
	}

	return &loadBalancer.Empty{}, nil
}