用Go实现yaml文件节点动态解析

1.摘要

在大多数Go语言项目中, 配置文件通常为yaml文件格式, 在文件中可以设置项目中可灵活配置的各类参数, 通常这类参数都是比较固定的, 可以将其映射为对应的结构体在项目中进行使用, 如果需要调整参数时, 只需要增减结构体参数字段内容即可。

但同时还存在另外一种情况, 例如: 在ubuntu系统中, netplan网卡配置文件同样也是yaml格式文件(配置文件在/etc/netplan目录下), 但该配置文件的节点内容可能是动态变化的, 例如:当dhcp开启或关闭时, 其节点展示的内容差异会很大, 要动态读取和写入对应的节点内容使用结构体已无法满足实际需求。

本章节主要分享一种动态解析yaml格式文件节点内容的相关知识。

2.静态解析方法

首先还是回顾一下静态解析的方法, 假如我们的yaml配置文件内容如下:

database:
  mysql:
    db_host: 192.168.201.200
    db_user: root
    db_port: 3306
    db_name: datas

以上是一个关于数据库连接方式的节点定义, 在Go代码中, 我们定义一个综合结构体:

type (
  Config struct {
    Database DatabaseConfig
  }

  DatabaseConfig struct {
    Mysql MysqlConfig
  }

  MysqlConfig struct {
    DbHost string `mapstructure:"db_host"`
    DbUser string `mapstructure:"db_user"`
    DbPassword string
    DbPort string `mapstructure:"db_port"`
    DbName string `mapstructure:"db_name"`
  }
)

在以上配置中, database是根节点, 子节点是mysql, 在子节点下有四个叶子节点db_host、db_user、db_port和db_name。在结构体中, MysqlConfig是代表叶子节点结构, 使用mapstructure关联了yaml配置文件中的字段名, 然后使用DatabaseConfig包含MysqlConfig, 使用Config包含DatabaseConfig, 与yaml文件中的节点层级一一对应。

在应用过程中也比较简单, 只需要以下代码即可将yaml配置文件中的内容解析到结构体:

var cfg Config
if err := unmarshal(&cfg); err != nil {
    return nil, err
}

3.动态解析方法

动态解析方法分为读和写两种方式, 在正式使用前,需要在工程中导入和同步:import "gopkg.in/yaml.v3", 然后我们看一下一个简单的网卡配置文件结构,如图:

在该配置文件中, 当dhcp4内容为true时,表示自动获取IP, 那么下面的addresses和name servers将是空的; 当dhcp4为false时, 下面的字段内容跟图中的一致, 并且ens22这个是网卡名称, 这个没有固定的名字, 网卡名称是动态变化的, 因此无法通过定义固定的结构体层级来解析内容。

看一段下面的代码:

import "gopkg.in/yaml.v3"
func main() {
  var err error
  var RootNode yaml.Node
  configs, _ := os.ReadFile(rootPath)
  err = yaml.Unmarshal(configs, &RootNode)
  if err != nil {
    log.Panic(err)
    return
  }
}

在上面的代码片段中, 我们没有定义任何结构体, 只定义了一个变量RootNode, 其类型为: yaml.Node, 然后使用通过os.ReadFile()函数读取网卡配置文件内容, 保存到变量configs中, 接着调用yaml.Unmarshal()函数将configs中的内容反序列化到RootNode变量中,那么RootNode变量中到底是一个怎样的结构呢? 实际上在RootNode变量中已经保存了配置文件所有节点的名称和内容, 通过Key:Value的方式在内存中保存。例如:

网卡配置文件中,根节点名为network, 所以network就作为一个key保存, 而network下面的所有内容就作为value保存, 看下内存的分布情况:

从上图中可以看到, 标号1的部分保存了1个元素, 这个元素实际上就是network, 在yaml节点中, 所有的内容都是保存在Content字段中, 所以在整个结构中, 可以递归的遍历Content内容来查找整个yaml文件中的所有节点名称和内容。

从上图的标号2中,我们可以看到network节点内容实际上被标记为!!map类型, 上面已经讲过, 节点的名称和内容都是通过key:value的类型在内存中保存, 所以其Content内容中有2个元素,一个元素是network节点名称,也就是Key名, 另一个元素就是network的value部分。那么这里有个问题, 在编写程序遍历的过程中, 如何区分key名和值的内容呢? 这里我们继续点开network树状结构,看一下key的内容,如图:

从上图可以看到, 实际上不管是Key还是Value,只要是字符串,其Tag内容都为"!!str", 同理,int内容其tag为"!!int", bool内容其tag为"!!bool", 如果某个字段的内容保存了多条内容, 那么该字段的Tag类型是"!!seq",例如配置文件中的DNS内容可以有多个,那么其字段的Tag内容就是!!seq, 如图:

在Go工程中,我们可以写一个递归函数专门查找Content内容,代码如下:

func findNode(n *yaml.Node, key string) *yaml.Node {
  switch n.Kind {
  case yaml.MappingNode:
    for i := 0; i < len(n.Content); i++ {
      if n.Content[i].Value == key {
        return n.Content[i+1]
      }
    }
    for i := 0; i < len(n.Content); i++ {
      if found := findNode(n.Content[i], key); found != nil {
        return found
      }
    }
  case yaml.SequenceNode:
    for i := 0; i < len(n.Content); i++ {
      if found := findNode(n.Content[i], key); found != nil {
        return found
      }
    }
  default:
    for i := 0; i < len(n.Content); i++ {
      if found := findNode(n.Content[i], key); found != nil {
        return found
      }
    }
  }
  return nil
}

在上面的代码中, yaml库使用yaml.MappingNode来识别Tag为"!!map"的内容;使用yaml.SequenceNode来识别Tag为"!!seq"的内容。注意: 上面findNode()函数只负责递归查找, 如果要读取或写入指定的节点内容, 我们仍然要控制节点的操作过程,例如: 我们要保存配置文件中addresses的内容, 当通过findNode函数找到address后,需要继续判断并获取值的内容,代码如下:

if foundObj.Kind != yaml.SequenceNode {
  err = errors.New("检测到网卡配置选项addresses的内容类型有误,请统一格式,IP地址前面加上-符号")
  return nil, err
}
if len(foundObj.Content) == 0 {
  err = errors.New("网卡配置选项addresses的内容为空,请确保网卡配置文件中的该参数至少有一条IP信息")
  return nil, err
}
if len(foundObj.Content) > 1 {
  err = errors.New("网卡配置选项addresses的内容不能存在多个,网卡配置信息存在格式错误")
  return nil, err
}
addressInfo := foundObj.Content[0]
if addressInfo.Tag != "!!str" {
  err = errors.New("检测到网卡配置选项addresses的内容不是字符串,网卡配置信息存在格式错误")
  return nil, err
}
totalInfo = append(totalInfo, addressInfo.Value)

同理, 如果要改变addresses内容, 只需要找到对应的Key, 改变其Value的内容即可,以下是参考代码:

if node.Kind != yaml.SequenceNode {
  err = errors.New("检测到网卡配置选项addresses的内容类型有误,请统一格式,IP地址前面加上-符号")
  return err
}
if len(node.Content) == 0 {
  err = errors.New("网卡配置选项addresses的内容为空,请确保网卡配置文件中的该参数至少有一条IP信息")
  return err
}
if len(node.Content) > 1 {
  err = errors.New("网卡配置选项addresses的内容不能存在多个,网卡配置信息存在格式错误")
  return err
}
addressInfo := node.Content[0]
if addressInfo.Tag != "!!str" {
  err = errors.New("检测到网卡配置选项addresses的内容不是字符串,网卡配置信息存在格式错误")
  return err
}
// NodeContent是从外面传参进来的修改的值,类型为list,默认只有一个元素,将其赋给value即可改变配置文件内容
addressInfo.Value = NodeContent[0].(string)

最终修改后的内容已经保存在我们上面定义的变量RootNode中,最后通过以下代码写回文件即可:

// 打开网卡文件
f, err := os.Create(NetcardFilePath)
if err != nil {
  logging.Log.Errorf("%T %s", err, err)
  return err
}
defer f.Close()

// 将节点内容序列化
d, err := yaml.Marshal(&RootNode)
if err != nil {
  logging.Log.Errorf("%T %s", err, err)
  return err
}

// 将序列化内容写入文件
if _, err = f.Write(d); err != nil {
  logging.Log.Errorf("%T %s", err, err)
  return err
}

if err = f.Sync(); err != nil {
  logging.Log.Errorf("%T %s", err, err)
  return err
}

4.总结

从上面的例子我们可以看到, 定义一个变量var RootNode yaml.Node, 无论是读取还是写入, 始终在操控yaml.Node中的树状结构, 树状结构存放map结构的方式是按照: key-value-key-value-key-value...交替顺序的方式存放, 因此在循环遍历的时候要注意,使用以下代码来取出节点名称和对应的值,也可以传入一个节点名称来查找指定节点和对应的值,代码如下:

for i := 0; i < len(found); i += 2 {
    content := found[i].Value
    if content == NodeName {
      node = found[i+1]
      break
    }
}

其中,found是调用上面函数findNode()查找到的节点位置,NodeName是需要查找的节点。其中found[i+1]可以取到所有的Key内容,found[i].Value可以取到对应的值。