Go程序包开发,读简单配置文件

蜜桃桃的冰淇淋奶昔 · · 491 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

1、概述

配置文件(Configuration File,CF)是一种文本文档,为计算机系统或程序配置参数和初始设置。传统的配置文件就是文本行,在 Unix 系统中随处可见,通常使用 .conf,.config,.cfg 作为后缀,并逐步形成了 key = value 的配置习惯。在 Windows 系统中添加了对 section 支持,通常用 .ini 作为后缀。面向对象语言的兴起,程序员需要直接将文本反序列化成内存对象作为配置,逐步提出了一些新的配置文件格式,包括 JSONYAMLTOML 等。

关于配置文件读写

现代配置文件的读写,官方网站一般会提供各种语言的配置读写包,而且大部分是开源的。

2、课程任务

任务目标

  1. 熟悉程序包的编写习惯(idioms)和风格(convetions)
  2. 熟悉 io 库操作
  3. 使用测试驱动的方法
  4. 简单 Go 程使用
  5. 事件通知

任务内容

在 Gitee 或 GitHub 上发布一个读配置文件程序包,第一版仅需要读 ini 配置,配置文件格式案例:

# possible values : production, development
app_mode = development

[paths]
# Path to where grafana can store temp files, sessions, and the sqlite3 db (if that is used)
data = /home/git/grafana

[server]
# Protocol (http or https)
protocol = http

# The http port  to use
http_port = 9999

# Redirect to correct domain if host header does not match domain
# Prevents DNS rebinding attacks
enforce_domain = true

|

任务要求

  1. 核心任务:包必须提供一个函数 Watch(filename,listener) (configuration, error)
    • 输入 filename 是配置文件名
    • 输入 listener 一个特殊的接口,用来监听配置文件是否被修改,让开发者自己决定如何处理配置变化
      • type ListenFunc func(string)
      • type inteface Listener { listen(inifile string) }
      • ListenFunc 实现接口方法 listen 直接调用函数
      • 优点
        • 所有满足签名的函数、方法都可以作为参数
        • 所有实现 Listener 接口的数据类型都可作为参数
    • 输出 configuration 数据类型,可根据 key 读对应的 value。 key 和 value 都是字符串
    • 输出 error 是错误数据,如配置文件不存在,无法打开等
    • 可选的函数 WatchWithOption(filename,listener,...) (configuration, error)
  2. 包必须包括以下内容:
    • 生成的中文 api 文档
    • 有较好的 Readme 文件,包括一个简单的使用案例
    • 每个go文件必须有对应的测试文件
    • 必须提供自定义错误
    • 使有 init 函数,使得 Unix 系统默认采用 # 作为注释行,Windows 系统默认采用 ; 作为注释行。
  3. 不能使用第三方包,但可以参考、甚至复制它们的代码。例如:
    • ini 读写包。 Github中文支持
    • Viper 读配置集成解决方案包。Github
      • live watching and re-reading of config files (optional)
    • fsnotify 文件系统通知包。 Github
    • 你可以参考这些代码,但不能在你的包中 import

下面是实现的代码,具体细节见注释部分

我在注释部分说明的很详细,就不再过多说明函数的作用

数据结构

type config struct {
    sectionList []string            //存key
    sections    map[string]*section //实际存储数据的地方(形成key和value的映射)
}

type section struct {
    keyValue map[string]string
}

watch函数

func Watch(filename string, listener Listener) (*config, error) {
    var cfg *config
    listener.Listen(filename)
    var e error = nil
    cfg, e = load(filename)
    return cfg, e
}

加载文件

func load(filename string) (*config, error) {
    f, err := os.Open(filename) //打开文件
    if err != nil {             //如果打开失败--遇到错误
        return nil, err
    }
    defer f.Close() //在函数执行结束后关闭文件

    buf := bufio.NewReader(f) //从文件里读取数据
    cfg, err := parse(buf)    //执行parse函数,详情见parse.go
    return cfg, err
}

初始化函数

func (cfg *config) init() {
    cfg.sections = make(map[string]*section) //初始化map
}

建立新的section

func (cfg *config) newSection(name string) error {
    if len(name) == 0 { //如果名字长度为0
        return errors.New("section name is empty")
    }
    if cfg.sections[name] != nil { //如果sections中某一项已经有数据
        return errors.New("already has same section name")

    }
    cfg.sectionList = append(cfg.sectionList, name) //扩展
    cfg.sections[name] = &section{
        keyValue: make(map[string]string),
    }
    return nil
}

根据系统来确定注释行符号

func init() { //根据系统来确定注释行符号
    switch runtime.GOOS {
    case "windows": //如果是windows系统
        notes = ";"
        lineBreaker = "\r\n"
    case "linux": //如果是linux系统
        notes = "#"
        lineBreaker = "\n"
    }
}

获取一行的数据

func getLine(buf *bufio.Reader, isEOF *bool) ([]byte, error) {
    line, err := buf.ReadBytes('\n') //按行读取数据
    if err == io.EOF {
        *isEOF = true
        err = nil
    } else if err != nil { //如果读取失败返回错误
        return nil, err
    }
    line = bytes.TrimLeftFunc(line, unicode.IsSpace)
    return line, err

}

解析section的名字

//解析section的名字
func parseSecName(line []byte, cfg *config) (string, error) {
    close := bytes.LastIndexByte(line, ']') //获得最后‘]’的下标
    if close == -1 {                        //如果缺少‘]’,报错
        return "", fmt.Errorf("unclosed section: %s", line)
    }
    secName := string(line[1:close]) //获取section的名字
    err := cfg.newSection(secName)   //开辟新空间并获得错误信息
    if err != nil {                  //如果存在错误,返回错误信息
        return "", err
    }
    return secName, nil
}

解析key的名字

//解析key的名字
func parseKeyName(line string) (string, int, error) {
    end := strings.IndexAny(line, keyValueDelim) //确定key-alue的分割符的下标
    if end < 0 {                                 //如果下表<0,即存在错误
        return "", -1, fmt.Errorf("delimiter(%s) not found", keyValueDelim)
    }
    return strings.TrimSpace(line[0:end]), end + 1, nil //这里返回的下标为分割符下标+1
}

解析value

//解析value
func parseValue(line string) (string, error) {
    line = strings.TrimSpace(line) //去空格
    if len(line) == 0 {            //如果长度为0
        return "", nil
    }
    i := strings.IndexAny(line, "#;") //处理一种情况‘key = value # this is comment’也就是注释在语句后方
    if i > -1 {
        line = strings.TrimSpace(line[:i])

    }
    return line, nil //由于之前直接返回的是key-value分割符下标+1,就是value开始的地方
}

解析函数

func parse(reader *bufio.Reader) (*config, error) {
    var cfg config
    cfg.init()     //初始化
    isEOF := false //文件是否关闭
    secName := defaultSection
    for !isEOF { //如果文件没有关闭则执行循环
        line, err := getLine(reader, &isEOF)
        if err != nil {
            return nil, err
        }
        if len(line) == 0 { //跳过空行
            continue
        }
        if line[0] == notes[0] { //跳过注释
            continue
        }
        if line[0] == '[' { //如果第0位是‘[’,即secname的前面一位
            secName, err = parseSecName(line, &cfg) //解析secname
            if err != nil {                         //如果解析错误返回错误
                return nil, err
            }
            continue
        }
        if len(cfg.sectionList) == 0 { //没有空间则开辟新空间
            err = cfg.newSection(secName)
            if err != nil {
                return nil, err
            }
        }
        keyName, offset, err := parseKeyName(string(line)) //解析keyname
        if err != nil {
            return nil, err
        }
        value, err := parseValue(string(line[offset:])) //解析value
        if err != nil {
            return nil, err
        }
        err = cfg.sections[secName].newKeyValue(keyName, value) //存key和value
        if err != nil {
            return nil, err
        }
    }
    return &cfg, nil
}

func (sec *section) newKeyValue(keyName string, value string) error {
    if _, ok := sec.keyValue[keyName]; ok {
        return fmt.Errorf("key(%v) already exists", keyName)
    }
    sec.keyValue[keyName] = value
    return nil
}

接下来是单元测试文件:

下面是对于几个核心函数的测试
测试parseSecName函数:

func TestParseSecName(t *testing.T) {
    var cfg Config
    var e error
    cfg.init()
    secName := defaultSection
    var line []byte
    line = []byte("[paths]")
    secName, e = parseSecName(line, &cfg)

    ex1 := "paths"

    var ex2 error

    if secName != ex1 {
        t.Errorf("ex1 wrong, '%s'", secName)
    }
    if e != ex2 {
        t.Errorf("ex2 wrong, '%s'", e)
    }

}

测试parseKeyName函数:

func TestParsekey(t *testing.T) {
    line := "app_mode = development"
    keyName, offset, err := parseKeyName(string(line))
    ex1, ex2 := "app_mode", 10
    var ex3 error
    if keyName != ex1 {
        t.Errorf("ex1 wrong")
    }
    if offset != ex2 {
        t.Errorf("ex2 wrong")
    }
    if err != ex3 {
        t.Errorf("ex3 wrong")
    }
}

测试parseValue函数:

func TestParseValue(t *testing.T) {
    line := "app_mode = development"
    value, err := parseValue(string(line[10:]))
    ex1 := "development"
    var ex2 error
    if value != ex1 {
        t.Errorf("ex1 wrong")
    }
    if err != ex2 {
        t.Errorf("ex2 wrong")
    }

}

测试parse函数:

func TestParse(t *testing.T) {
    var e error
    f, err := os.Open("./testdata/test.ini")
    if e != err {
        t.Errorf("open file filed")
    }
    defer f.Close()
    buf := bufio.NewReader(f)
    _, erro := parse(buf)
    if erro != e {
        t.Errorf("parse filed")
    }

}

测试结果:

生成API文档

先通过指令go get golang.org/x/tools/cmd/godoc来安装godoc。

然后执行godoc
在浏览器打开https://localhost:6060/pkg/

之后保存

实验测试:

需要先安装fsnotify

测试所用代码:
main函数:

func main() {
    cfg, err := configuration.Load("test.ini")
    if err != nil {
        fmt.Println(err)
        return
    }
    printCfg(cfg)

    var lis configuration.ListenFunc = func(filename string) {
        watcher, err := fsnotify.NewWatcher()
        if err != nil {
            log.Fatal(err)
        }
        defer watcher.Close()
        done := make(chan bool)
        go func() {
            for {
                select {
                case event, ok := <-watcher.Events:
                    if !ok {
                        return
                    }
                    if event.Op&fsnotify.Write == fsnotify.Write {
                        return
                    }
                    done <- true
                    return
                case err, ok := <-watcher.Errors:
                    if !ok {
                        return
                    }
                    log.Println("error:", err)
                }
            }
        }()
        watcher.Add(filename)
        <-done
    }
    cfg, err = configuration.Watch("test.ini", lis)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("")
    fmt.Println("after change:")
    printCfg(cfg)

}

打印函数:

func printCfg(cfg *configuration.Config) {
    for _, secName := range cfg.SectionList {
        sec := cfg.Sections[secName]
        fmt.Printf("[%s]\n", secName)
        for _, key := range sec.KeyList {
            fmt.Printf("%s = %s\n", key, sec.KeyValue[key])
        }
    }
}

更改文件前:

更改文件后:

输出:

测试成功!

代码地址


有疑问加站长微信联系(非本文作者)

本文来自:简书

感谢作者:蜜桃桃的冰淇淋奶昔

查看原文:Go程序包开发,读简单配置文件

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:692541889

491 次点击  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传