github.com/polarismesh/polaris@v1.17.8/config/utils.go

/*
 * Tencent is pleased to support the open source community by making Polaris available.
 *
 * Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved.
 *
 * Licensed under the BSD 3-Clause License (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * https://opensource.org/licenses/BSD-3-Clause
 *
 * Unless required by applicable law or agreed to in writing, software distributed
 * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 * CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 */

package config

import (
	"archive/zip"
	"bytes"
	"crypto/md5"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"path"
	"regexp"
	"strconv"
	"strings"
	"unicode/utf8"

	"github.com/golang/protobuf/ptypes/wrappers"
	apiconfig "github.com/polarismesh/specification/source/go/api/v1/config_manage"
	apimodel "github.com/polarismesh/specification/source/go/api/v1/model"

	api "github.com/polarismesh/polaris/common/api/v1"
	"github.com/polarismesh/polaris/common/model"
	"github.com/polarismesh/polaris/common/utils"
)

var (
	regSourceName = regexp.MustCompile(`^[\dA-Za-z-.:_]+$`)
	regFileName   = regexp.MustCompile(`^[\dA-Za-z-./:_]+$`)
)

// CheckResourceName 检查资源名称
func CheckResourceName(name *wrappers.StringValue) error {
	if name == nil {
		return errors.New(utils.NilErrString)
	}

	if name.GetValue() == "" {
		return errors.New(utils.EmptyErrString)
	}

	if ok := regSourceName.MatchString(name.GetValue()); !ok {
		return errors.New("name contains invalid character")
	}

	return nil
}

// CheckFileName 校验文件名
func CheckFileName(name *wrappers.StringValue) error {
	if name == nil {
		return errors.New(utils.NilErrString)
	}

	if name.GetValue() == "" {
		return errors.New(utils.EmptyErrString)
	}

	if ok := regFileName.MatchString(name.GetValue()); !ok {
		return errors.New("name contains invalid character")
	}

	return nil
}

// CalMd5 计算md5值
func CalMd5(content string) string {
	h := md5.New()
	h.Write([]byte(content))
	return hex.EncodeToString(h.Sum(nil))
}

// CheckContentLength 校验文件内容长度
func CheckContentLength(content string, max int) error {
	if utf8.RuneCountInString(content) > max {
		return fmt.Errorf("content length too long. max length =%d", max)
	}

	return nil
}

// GenConfigFileResponse 为客户端生成响应对象
func GenConfigFileResponse(namespace, group, fileName, content, md5str string,
	version uint64) *apiconfig.ConfigClientResponse {
	configFile := &apiconfig.ClientConfigFileInfo{
		Namespace: utils.NewStringValue(namespace),
		Group:     utils.NewStringValue(group),
		FileName:  utils.NewStringValue(fileName),
		Content:   utils.NewStringValue(content),
		Version:   utils.NewUInt64Value(version),
		Md5:       utils.NewStringValue(md5str),
	}
	return api.NewConfigClientResponse(apimodel.Code_ExecuteSuccess, configFile)
}

type kv struct {
	Key   string
	Value string
}

// ToTagJsonStr 把 Tags 转化成 Json 字符串
func ToTagJsonStr(tags []*apiconfig.ConfigFileTag) string {
	if len(tags) == 0 {
		return "[]"
	}
	kvs := make([]kv, 0, len(tags))
	for _, tag := range tags {
		kvs = append(kvs, kv{
			Key:   tag.Key.GetValue(),
			Value: tag.Value.GetValue(),
		})
	}

	ret, err := json.Marshal(kvs)
	if err != nil {
		return "[]"
	}
	return string(ret)
}

// FromTagJson 从 Tags Json 字符串里反序列化出 Tags
func FromTagJson(tagStr string) []*apiconfig.ConfigFileTag {
	if tagStr == "" {
		return nil
	}

	kvs := make([]kv, 0, 10)
	err := json.Unmarshal([]byte(tagStr), &kvs)
	if err != nil {
		return nil
	}

	tags := make([]*apiconfig.ConfigFileTag, 0, len(kvs))
	for _, val := range kvs {
		tags = append(tags, &apiconfig.ConfigFileTag{
			Key:   utils.NewStringValue(val.Key),
			Value: utils.NewStringValue(val.Value),
		})
	}

	return tags
}

// GenReleaseName 生成发布名称，规则是 filename-${三位自增长序列}
func GenReleaseName(oldReleaseName, fileName string) string {
	if oldReleaseName == "" {
		return fileName + "-001"
	}

	nameInfo := strings.Split(oldReleaseName, "-")
	if len(nameInfo) != 2 {
		return oldReleaseName
	}

	if fileName != nameInfo[0] {
		return oldReleaseName
	}

	num, err := strconv.ParseInt(nameInfo[1], 10, 64)
	if err != nil {
		return oldReleaseName
	}

	return fileName + "-" + strings.ReplaceAll(fmt.Sprintf("%3d", num+1), " ", "0")
}

func CompressConfigFiles(files []*model.ConfigFile,
	fileID2Tags map[uint64][]*model.ConfigFileTag, isExportGroup bool) (*bytes.Buffer, error) {
	var buf bytes.Buffer
	w := zip.NewWriter(&buf)
	defer w.Close()

	var configFileMetas = make(map[string]*utils.ConfigFileMeta)
	for _, file := range files {
		fileName := file.Name
		if isExportGroup {
			fileName = path.Join(file.Group, file.Name)
		}

		configFileMetas[fileName] = &utils.ConfigFileMeta{
			Tags:    make(map[string]string),
			Comment: file.Comment,
		}
		for _, tag := range fileID2Tags[file.Id] {
			configFileMetas[fileName].Tags[tag.Key] = tag.Value
		}
		f, err := w.Create(fileName)
		if err != nil {
			return nil, err
		}
		if _, err := f.Write([]byte(file.Content)); err != nil {
			return nil, err
		}
	}
	// 生成配置元文件
	f, err := w.Create(utils.ConfigFileMetaFileName)
	if err != nil {
		return nil, err
	}
	data, err := json.MarshalIndent(configFileMetas, "", "\t")
	if err != nil {
		return nil, err
	}
	if _, err := f.Write(data); err != nil {
		return nil, err
	}
	return &buf, nil
}