sutong/complie-erlang
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

优化缓存机制 补充错误码

Browse Source
This commit is contained in:
Kaxi
2025-10-09 02:04:32 +08:00
parent 73480005eb
commit 84899f9935
10 changed files with 596 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cache/cache.go
Vendored
+78
View File
@@ -0,0 +1,78 @@
package cache
import (
"encoding/json"
"os"
"sync"
)
type Cache interface {
Get(key string) (any, bool)
GetDefault(key string, defaultValue any) (any, error)
Set(key string, val any) error
Iteration(func(key string, val any))
}
type cache struct {
filename string
data map[string]any
mu sync.Mutex
}
func (c *cache) Get(key string) (any, bool) {
c.mu.Lock()
defer c.mu.Unlock()
val, ok := c.data[key]
return val, ok
}
func (c *cache) GetDefault(key string, defaultVal any) (any, error) {
c.mu.Lock()
defer c.mu.Unlock()
val, ok := c.data[key]
if ok {
return val, nil
}
c.data[key] = defaultVal
bytes, err := json.Marshal(c.data)
if err != nil {
return defaultVal, err
}
err = os.WriteFile(c.filename, bytes, 0666)
return defaultVal, err
}
func (c *cache) Set(key string, val any) error {
c.mu.Lock()
defer c.mu.Unlock()
c.data[key] = val
bytes, err := json.Marshal(c.data)
if err != nil {
return err
}
return os.WriteFile(c.filename, bytes, 0666)
}
func (c *cache) Iteration(f func(key string, val any)) {
for k, v := range c.data {
f(k, v)
}
}
func NewCache(filename string) (Cache, error) {
var c = &cache{
filename: filename,
data: make(map[string]any),
}
bytes, err := os.ReadFile(filename)
if err != nil {
return c, nil
}
if err = json.Unmarshal(bytes, &c.data); err != nil {
return c, err
}
return c, nil
}
cmd/cache.go
+71
View File
@@ -0,0 +1,71 @@
package cmd
import (
"complie-erlang/cache"
"complie-erlang/parser/zm_lib"
"fmt"
"github.com/spf13/cobra"
)
type cacheSet struct {
Path string
debug bool
}
func (c *cacheSet) Run(cmd *cobra.Command, args []string) {
if len(args) == 0 {
fmt.Println("No command specified.")
return
}
if err := c.run(args); err != nil {
fmt.Println(err)
return
}
fmt.Println("Done.")
}
func (c *cacheSet) run(args []string) error {
pathByExecutable, err := zm_lib.FindPathByExecutable(c.Path)
if err != nil {
return err
}
newCache, err := cache.NewCache(pathByExecutable)
if err != nil {
return err
}
switch args[0] {
case "set":
return newCache.Set(args[1], args[2])
case "get":
val, is := newCache.Get(args[1])
if is {
fmt.Printf("%s : %s \n", args[0], val)
} else {
fmt.Printf("%s : nil \n", args[0])
}
default:
return fmt.Errorf("unknown command: %s", args[0])
}
return nil
}
func init() {
var singleSet = new(cacheSet)
var logsCmd = &cobra.Command{
Use: "global",
Short: "缓存数据模版",
Long: `构建功能数据`,
Run: singleSet.Run,
}
logsCmd.PersistentFlags().BoolVar(&singleSet.debug, "debug", false, "是否启动调试模式")
logsCmd.PersistentFlags().StringVar(&singleSet.Path, "path", globalCacheFileName, "缓存数据存放地址(相对于根目录)")
rootCmd.AddCommand(logsCmd)
}
cmd/errcode.go
+70 -9
View File
@@ -1,11 +1,12 @@
package cmd
import (
"complie-erlang/cache"
"complie-erlang/parser"
"complie-erlang/parser/zm_lib"
"fmt"
"github.com/spf13/cobra"
"log"
"os"
"path/filepath"
)
@@ -18,6 +19,46 @@ type ErrCode struct {
}
func (s *ErrCode) run(_ *cobra.Command, arg []string) {
if len(arg) == 0 {
arg = append(arg, "show")
}
switch arg[0] {
case "merge":
newCache, err := cache.NewCache("errorCode.json")
if err != nil {
log.Printf("[error] newCache err:%s", err.Error())
return
}
fmt.Println("")
newCache.Iteration(func(key string, val any) {
fmt.Printf(" key:%s val:%s\n", key, val)
})
fmt.Println("ok")
case "set":
newCache, err := cache.NewCache("errorCode.json")
if err != nil {
log.Printf("[error] newCache err:%s", err.Error())
return
}
if len(arg) != 3 {
log.Printf("[error] len(arg):%d %s", len(arg), arg)
return
}
err = newCache.Set(arg[1], arg[2])
fmt.Println("err:", err)
case "get":
newCache, err := cache.NewCache("errorCode.json")
if err != nil {
log.Printf("[error] newCache err:%s", err.Error())
return
}
fmt.Println("")
newCache.Iteration(func(key string, val any) {
fmt.Printf(" key:%s val:%s\n", key, val)
})
fmt.Println("")
default:
pluginPathByWd, err := zm_lib.GetPluginPathByWd(s.Plugin)
if err != nil {
log.Printf("[warn] plugin path no find:%s", err.Error())
@@ -25,14 +66,24 @@ func (s *ErrCode) run(_ *cobra.Command, arg []string) {
}
errPath := filepath.Join(pluginPathByWd, s.ErrPath)
fmt.Printf("errPath:%s %s\n", pluginPathByWd, errPath)
errorLanguageBytes, err := os.ReadFile(errPath)
clientCfg, err := parser.NewClientConfigWithFile(errPath)
if err != nil {
log.Printf("[error] read errPath:%s %s\n", errPath, err.Error())
log.Printf("[error] load errPath:%s %s\n", errPath, err.Error())
return
}
fmt.Printf("errPath:%s %s\n", errorLanguageBytes, errPath)
errCode := parser.NewErrCode(clientCfg)
err = errCode.LoadWd()
newCache, err := cache.NewCache("errorCode.json")
if err != nil {
log.Printf("[error] newCache err:%s", err.Error())
return
}
_ = errCode.PrintErrCode(newCache)
fmt.Printf("err:%v \n", err)
}
}
@@ -40,14 +91,24 @@ func init() {
var singleSet = new(ErrCode)
var logsCmd = &cobra.Command{
Use: "err_code",
Short: "根据proto 文件构建 功能模版",
Long: `构建功能数据`,
Short: "检索代码模块生成错误码配置",
Long: `检索代码模块生成错误码配置
更多用法:
- 查看缓存区 get
- 设置缓存区 set <错误码> <错误码翻译设置>
- 提交缓存区 merge <功能名称>
`,
Run: singleSet.run,
PostRun: func(cmd *cobra.Command, args []string) {
fmt.Println("\n-h 可解锁更多用法")
},
}
logsCmd.PersistentFlags().BoolVar(&singleSet.debug, "debug", false, "是否启动调试模式")
logsCmd.PersistentFlags().StringVar(&singleSet.ErrPath, "path", ".cfg/ErrorLanguage.txt", "错误码地址(相对于根目录)")
logsCmd.PersistentFlags().StringVar(&singleSet.Plugin, "plugin", "plugin", "代码根目录")
_ = zm_lib.PersistentFlagsStringVar(logsCmd, &singleSet.ErrPath, globalCache, "path", "cfg/ErrorLanguagePackage.txt", "错误码地址(相对于根目录)")
_ = zm_lib.PersistentFlagsStringVar(logsCmd, &singleSet.Plugin, globalCache, "plugin", "plugin", "代码根目录")
rootCmd.AddCommand(logsCmd)
}
cmd/pb2port.go
+13 -9
View File
@@ -9,7 +9,6 @@ import (
"log"
"os"
"path/filepath"
"strings"
)
type Pb2Port struct {
@@ -113,20 +112,25 @@ func init() {
// 写入默认数据
if currentDir, err := os.Getwd(); err == nil {
out = fmt.Sprintf("%s_port.erl", filepath.Base(currentDir))
pluginSpilt := strings.Split(currentDir, "plugin")
if len(pluginSpilt) > 0 {
pluginSpilt = pluginSpilt[:len(pluginSpilt)-1]
protoPath = filepath.Join(strings.Join(pluginSpilt, "plugin"), fmt.Sprintf("\\gpb\\game\\pro_%s.proto", filepath.Base(currentDir)))
outPut, _ := globalCache.GetDefault(fmt.Sprintf("%s.out", logsCmd.Use), "%s_port.erl")
out = fmt.Sprintf(outPut.(string), filepath.Base(currentDir))
plugin, _ := globalCache.GetDefault(fmt.Sprintf("%s.Plugin", logsCmd.Use), "plugin")
pluginPathByWd, err := zm_lib.GetPluginPathByWd(plugin.(string))
if err == nil {
defaultProtoPath, _ := globalCache.GetDefault(fmt.Sprintf("%s.Proto", logsCmd.Use), "\\gpb\\game\\pro_%s.proto")
protoPath = filepath.Join(pluginPathByWd, fmt.Sprintf(defaultProtoPath.(string), filepath.Base(currentDir)))
}
}
logsCmd.PersistentFlags().BoolVar(&singleSet.debug, "debug", false, "是否启动调试模式")
logsCmd.PersistentFlags().StringVar(&singleSet.protoPath, "proto", protoPath, "读取文件")
logsCmd.PersistentFlags().StringVar(&singleSet.out, "out", out, "输出文件")
logsCmd.PersistentFlags().StringVar(&singleSet.author, "author", "st,sutong@youkia.net", "作者")
logsCmd.PersistentFlags().StringVar(&singleSet.mainTemplate, "main_tpl", "ErlangPort", "主模版")
logsCmd.PersistentFlags().StringVar(&singleSet.tplDir, "tpl", "./templates/*.tpl", "模版地址")
_ = zm_lib.PersistentFlagsStringVar(logsCmd, &singleSet.author, globalCache, "author", "st,sutong@youkia.net", "作者")
_ = zm_lib.PersistentFlagsStringVar(logsCmd, &singleSet.mainTemplate, globalCache, "main_tpl", "ErlangPort", "主模版")
_ = zm_lib.PersistentFlagsStringVar(logsCmd, &singleSet.tplDir, globalCache, "tpl", "./templates/*.tpl", "模版地址")
//logsCmd.PersistentFlags().StringVar(&singleSet.mainTemplate, "main_tpl", "ErlangPort", "主模版")
//logsCmd.PersistentFlags().StringVar(&singleSet.tplDir, "tpl", "./templates/*.tpl", "模版地址")
rootCmd.AddCommand(logsCmd)
}
cmd/root.go
+19
View File
@@ -1,11 +1,30 @@
package cmd
import (
"complie-erlang/cache"
"complie-erlang/parser/zm_lib"
"fmt"
"github.com/spf13/cobra"
"os"
)
// 全局缓存
var globalCache = InitGlobalCache()
const globalCacheFileName = "global.json"
func InitGlobalCache() cache.Cache {
pathByExecutable, err := zm_lib.FindPathByExecutable(globalCacheFileName)
if err != nil {
panic("未查找到根目录 Err:" + err.Error())
}
newCache, err := cache.NewCache(pathByExecutable)
if err != nil {
panic("创建缓存失败 Err:" + err.Error())
}
return newCache
}
var rootCmd = &cobra.Command{
Use: "",
Short: "erlang注解生成配置模版工具",
config/plugin.go
+40
View File
@@ -0,0 +1,40 @@
package config
import (
"complie-erlang/parser/zm_proto"
"time"
)
type PluginConfig struct {
Name string
Desc string
CreatAt time.Time
Type PluginType // 项目类型
// 差异数据
ProtoDir string // 接口proto 地址
CfgDir string // 配置地址
FunOpenId int
Port []zm_proto.Port
ErrorCodes map[string]string
}
type Plugin interface {
Init(args []string) error
}
type PluginType string
var (
PluginTypeGame PluginType = "Game"
PluginTypeGm = "Gm"
PluginTypeGmActivity = "GmActivity"
)
const pluginPath = "./plugin.json"
func (p *PluginConfig) Init(args []string) error {
// 创建配置文件
// 根据类型创建各种 初始化文件
return nil
}
parser/clientConfig.go
+163
View File
@@ -0,0 +1,163 @@
package parser
import (
"bufio"
"fmt"
"io"
"os"
"strings"
"sync"
)
type ClientConfig struct {
Types map[int]ClientValue
TypeName2Index map[string]int
Data map[string]map[int]string
mu sync.RWMutex
}
type ClientValue struct {
Desc string
Type string
Name string
}
func NewClientConfig() *ClientConfig {
return &ClientConfig{
Types: make(map[int]ClientValue),
Data: make(map[string]map[int]string),
TypeName2Index: make(map[string]int),
mu: sync.RWMutex{},
}
}
func NewClientConfigWithFile(filename string) (*ClientConfig, error) {
c := NewClientConfig()
return c, c.LoadFile(filename)
}
func (c *ClientConfig) LoadFile(filename string) error {
file, err := os.Open(filename)
if err != nil {
return err
}
defer file.Close()
c.mu.Lock()
defer c.mu.Unlock()
return c.loadByReader(bufio.NewReader(file))
}
func (c *ClientConfig) LoadByReader(reader io.Reader) error {
c.mu.Lock()
defer c.mu.Unlock()
return c.loadByReader(reader)
}
func (c *ClientConfig) loadByReader(reader io.Reader) error {
// 创建缓存读取 分隔符设置成 回车
scan := bufio.NewScanner(reader)
scan.Split(bufio.ScanLines)
var line int
var types []string
var desc []string
for scan.Scan() {
line++
lineContent := strings.TrimSpace(scan.Text())
if len(lineContent) == 0 {
continue
}
// 去除注释
split := strings.Split(lineContent, "//")
if len(split) > 1 {
lineContent = split[0]
}
// 类型
if line == 1 {
types = strings.Split(lineContent, "\t")
continue
}
// 备注
if line == 2 {
desc = strings.Split(lineContent, "\t")
continue
}
// key
if line == 3 {
for i, t := range strings.Split(lineContent, "\t") {
if len(types) < i {
return fmt.Errorf("line %d: invalid type", line)
}
if len(desc) < i {
return fmt.Errorf("line %d: invalid desc", line)
}
c.Types[i] = ClientValue{
Desc: desc[i],
Type: types[i],
Name: t,
}
c.TypeName2Index[t] = i
}
continue
}
var lineData = make(map[int]string)
var lineKey string
for i1, v1 := range strings.Split(lineContent, "\t") {
if i1 == 0 {
lineKey = strings.TrimSpace(v1)
}
lineData[i1] = strings.TrimSpace(v1)
}
if len(lineData) == 0 {
continue
}
c.Data[lineKey] = lineData
}
return nil
}
// Value 读取单个
func (c *ClientConfig) Value(key string, objKey string) (ClientValue, string, error) {
c.mu.RLock()
defer c.mu.RUnlock()
l, is := c.Data[key]
if !is {
return ClientValue{}, "", fmt.Errorf("key %s not found", key)
}
index, is2 := c.TypeName2Index[objKey]
if !is2 {
return ClientValue{}, "", fmt.Errorf("objKey %s not found", objKey)
}
return c.Types[index], l[index], nil
}
// ValueByLine 读取
func (c *ClientConfig) ValueByLine(line map[int]string, key string) (ClientValue, string, error) {
c.mu.RLock()
defer c.mu.RUnlock()
index, is2 := c.TypeName2Index[key]
if !is2 {
return ClientValue{}, "", fmt.Errorf("objKey %s not found", key)
}
return c.Types[index], line[index], nil
}
// LineByKey 通过Key获取一行
func (c *ClientConfig) LineByKey(key string) map[int]string {
c.mu.RLock()
defer c.mu.RUnlock()
return c.Data[key]
}
parser/errCode.go
+108
View File
@@ -0,0 +1,108 @@
package parser
import (
"complie-erlang/cache"
"complie-erlang/parser/zm_lib"
"fmt"
"os"
"path/filepath"
"regexp"
)
type ErrCode struct {
codeMap map[string]bool
ClientConfig *ClientConfig
}
func NewErrCode(c *ClientConfig) *ErrCode {
return &ErrCode{
codeMap: make(map[string]bool),
ClientConfig: c,
}
}
func (e *ErrCode) LoadWd() error {
wdDir, err := zm_lib.FindPathByWd(".")
if err != nil {
return err
}
return e.iterationDir(wdDir)
}
func (e *ErrCode) iterationDir(baseDir string) error {
dir, err := os.ReadDir(baseDir)
if err != nil {
return err
}
for _, d := range dir {
if d.IsDir() {
err = e.iterationDir(filepath.Join(filepath.Join(baseDir, d.Name())))
if err != nil {
return err
}
continue
}
path := filepath.Join(baseDir, d.Name())
if err = e.loadFile(path); err != nil {
return err
}
}
return nil
}
func (e *ErrCode) loadFile(filename string) error {
bytes, err := os.ReadFile(filename)
if err != nil {
return err
}
// 定义正则表达式
// 注意：由于\?在Go的字符串中是一个特殊字符，我们使用\\?来表示一个问号。
// 同时，由于双引号在正则表达式中有特殊含义，我们需要使用\\"来表示一个普通双引号。
// 我们使用非贪婪匹配来确保只匹配到第一个双引号后的内容。
re := regexp.MustCompile(`(?:\\?\?ThrowErr|throw)\("([^"]+)"\)`)
// 查找所有匹配项
matches := re.FindAllStringSubmatch(string(bytes), -1)
// 提取并打印双引号内的内容
for _, match := range matches {
// match[0] 是整个匹配的字符串，match[1] 是第一个括号内的匹配（即双引号内的内容）
if e.codeMap[match[1]] {
continue
}
e.codeMap[match[1]] = true
}
return nil
}
func (e *ErrCode) PrintErrCode(c cache.Cache) error {
fmt.Println(">")
for key := range e.codeMap {
line := e.ClientConfig.LineByKey(key)
if line == nil {
val, is := c.Get(key)
if is {
fmt.Printf(" %s: %v[cache] \n", key, val)
} else {
fmt.Printf(" %s: %v \n", key, nil)
}
} else {
_, s, err := e.ClientConfig.ValueByLine(line, "UserCN")
if err != nil {
return err
}
fmt.Printf(" %s: %s \n", key, s)
}
}
fmt.Println()
return nil
}
parser/zm_lib/cmd_lib.go
+14
View File
@@ -0,0 +1,14 @@
package zm_lib
import (
"complie-erlang/cache"
"fmt"
"github.com/spf13/cobra"
)
func PersistentFlagsStringVar(cmd *cobra.Command, varK *string, cache cache.Cache, globalKey string, defaultValue string, desc string) error {
pluginKey := fmt.Sprintf("%s.%s", cmd.Use, globalKey)
plugin, err := cache.GetDefault(pluginKey, defaultValue)
cmd.PersistentFlags().StringVar(varK, globalKey, plugin.(string), fmt.Sprintf("%s (global.key:\"%s\")", desc, pluginKey))
return err
}
parser/zm_lib/public_tools.go
+10
View File
@@ -67,6 +67,16 @@ func FindPathByBasePath(basefun func() (basePath string, err error), path string
if err != nil {
return "", err
}
info, err := os.Stat(basePath)
if err != nil {
return "", err
}
if !info.IsDir() {
path = filepath.Join(filepath.Dir(basePath), path)
} else {
path = filepath.Join(basePath, path)
}
return path, nil
}