go 程序包开发，读简单配置文件 v1

一、作业要求

https://pmlpml.gitee.io/service-computing/post/ex-pkg-ini/

二、具体实现

watch函数需要实现两个功能，分别是读ini配置文件和监听文件在这一过程中是否发生变化。接下来分别讲如何实现这两个功能。

（一）Read读配置文件

https://ini.unknwon.io/docs/intro/getting_started介绍了解析ini文件的一个范例，我们的目的是实现其一部分功能，分别是获取段落的方法getSection() 和获取段落中键对应的值的方法getValByKey() 。

1. 首先定义接口和数据结构

section.go中定义了一个段的结构Section，它包含一个字典，字典的键和值都为string类型。
Section这个结构实现了getValByKey() 。
文件中还定义了New一个Section的方法，对其中的字典结构做了初始化，所以在程序中可以这样写：

sec := NewSection()

就获得了一个新分配的Section的指针。

//Section 定义了一个段落的内容
type Section struct {
    
	mp map[string]string
}
func (sec *Section) GetValByKey(key string) string {
    
	return sec.mp[key]
}

func NewSection() *Section {
    
	return &Section {
    
		mp: make(map[string]string),
	}
}

你可以在section_test.go中看到相关的测试。

另一个结构iniCFG定义在read.go中，它存储了一整个ini文件的内容，其结构内部也是一个字典，键是string类型，值是Section的指针类型。（使用Section对象的指针而不是Section，一方面是为了函数调用更快，另一方面是希望实现这样的效果：即使一个Section已经存在iniCFG中，修改这个Section时iniCFG中的内容也会跟着修改）。

iniCFG实现了getSection() 方法，以及与Section类似，可以通过NewiniCFG来获得一个已经初始化好的iniCFG对象的指针。

//iniCFG 定义了配置文件内容的存储结构
type iniCFG struct {
    
	mp map[string]*Section
}

func NewIniCFG() *iniCFG {
    
	return &iniCFG {
    
		mp: make(map[string]*Section),
	}
}

func (cfg *iniCFG) GetSection(secName string) (*Section, error) {
    
	mpSecName, isPresent := cfg.mp[secName]
	if isPresent == false {
    
		return mpSecName, SecNameDoesNotExist {
    secName}
	}
	return mpSecName, nil
}

iniCFG的测试在read_test.go文件中第一个函数。

2. 数据结构和方法都准备好了，接着就读取文件，将文件的信息存储在数据结构中

我的实现方法比较笨，先将文件内容转化为一个字符串，然后遍历字符串的每一个字符，找到段名、变量名和变量值并存入iniCFG结构中。
最后将iniCFG结构传入信道中，留待其他线程读取和使用。

func Read(filename string, ch_cfg chan *iniCFG) {
    
	//获取文件内容
	content, err := ioutil.ReadFile("data.ini")
    if err != nil {
    
        panic(err)
    }
	
	//fmt.Print(string(content))
	//readCount++
	//解析文件内容并存储在cfg中
	cfg := NewIniCFG()
	sec := NewSection()
	cfg.mp[""] = sec
	var key, value string
	var j int
	for i := 0; i < len(content);  {
    
		//下面的一行仅在测试时需要用到
		//time.Sleep(time.Duration(150) * time.Millisecond)
		ch := content[i]
		//如果是注释符号，则将整行忽略掉
		if ch == commentSymbol {
    
			for i < len(content) && content[i] != '\n' {
    
				i++
			}
		} else if ch == '[' {
    //如果是左中括号，则获取括号中的字符串作为段名，注意不能包括左右括号
			i++
			for i < len(content) && (content[i] == ' ' || content[i] == '\t' || content[i] == '\n') {
    
				i++
			}
			j = i
			for i < len(content) && !(content[i] == ' ' || content[i] == '\t' || content[i] == '\n' || content[i] == ']') {
    
				i++
			}
			secName := string(content[j:i])
			sec = NewSection()
			cfg.mp[secName] = sec

			// fmt.Print("hahahahaha")
			// fmt.Print(secName)

			for i < len(content) && content[i] != ']' {
    
				i++
			}
			i++
			
		} else if ch == ' ' || ch == '\t' || ch == '\n' {
     //如果是空格等，则跳过
			i++
		} else {
     //是键值对，则分别读取等号左侧和右侧字符串，并存入当前的段对应的字典中
			j = i
			for i < len(content) && !(content[i] == '='  || content[i] == '\t' || content[i] == ' ' || content[i] == '\n')  {
    
				i++
			}
			key = string(content[j:i])
			// fmt.Print("hahahahaha")
			// fmt.Print(key)
			for i < len(content) && content[i] != '=' {
    
				i++
			}
			i++
			for i < len(content) && (content[i] == ' ' || content[i] == '\t' || content[i] ==  '\n') {
    
				i++
			}
			j = i
			for i < len(content) && !(content[i] == ' ' || content[i] ==  '\t' || content[i] ==  '\n') {
    
				i++
			}
			value = string(content[j:i])
			sec.mp[key] = value
		}
		
	}
	finishRead = true
	//readCount--
	ch_cfg <- cfg
}

注意到一点，当文件读取完后，全局变量finishRead被设为true，这在后面会用到。

关于读取ini配置文件应该有更简洁的方法，比如每次读取一行。
可以参考一下这个http://c.biancheng.net/view/5407.html

可以在read_test.go文件中的第二个函数TestRead看到对读取整个ini文件的测试。
不过现在还不急，因为监听还未实现。

（二）Listen监听文件变化

1. 定义与实现listener接口方法

listener接口只包含了一个方法listen，参数是要监听的文件的名字，以及一个信道，用于向主线程watch传递信息。（前面也讲过，Read函数同样有一个信道，向主线程传递存储文件信息的iniCFG结构）

MyListener实现了listen方法。大致的实现如下：

• 获取文件上一次修改的时间lastModTime
• 在一个无限循环中一直获取文件的修改时间，与lastModTime比较，如果两个值不同则说明文件被修改，向信道ch中传一个值1
• 如果全局变量finishRead被设为true，说明文件已经读取完毕，向信道中传一个值0，并终止监听。

type Listener interface {
    
	listen(filename string, ch chan int )
}

type MyListener struct {
    

}

func (listener MyListener) listen(filename string, ch chan int ) {
    
	lastModTime := GetFileModTime(filename)
	for {
    
		
		modTime := GetFileModTime(filename)
		if (modTime != lastModTime) {
    
			lastModTime = modTime
			fmt.Print("fie changed, restart reading.\n")
			ch <- 1
			
		}
		if (finishRead) {
    
			ch <- 0
			return
		}
	}
}

（三）主线程函数Watch的实现

watch函数分别调用了Read函数和listen函数，且它们都在新的go程中运行。

首先运行listen函数，开始监听文件是否被修改

紧接着运行Read函数，开始读取ini配置文件

在一个无限for循环中获取来自listen传到信道ch中的值，如前所述，值为1时说明文件在读的过程被修改了，那么新开一个go程重新运行Read函数，新开的go程传到信道ch_cfg中的值会覆盖以前的go程传到ch_cfg中的值（其实也不一定，毕竟线程的运行顺序比较难把控，有可能以前的go程覆盖掉现在的go程，但暂时不细究这一点）；如果信道ch中的值为0，说明最新的go程中运行的Read函数执行结束，且这个过程中文件没有被修改，那么就可以获取ch_cfg中的值并返回了。

//Watch 读取ini配置文件，将信息存储在CFG结构中并返回
//listener 是监听器，在另一个go程中运行，如果读取文件过程中文件内容发生改变，则通过信道告知当前进程，当前进程重开一个go程，重新读取
func Watch(filename string ,listener Listener) (*iniCFG, error) {
    
	ch := make(chan int)
	ch_cfg := make(chan *iniCFG)
	go listener.listen(filename, ch)
	go Read(filename, ch_cfg)
	
	for {
    
		ret := <-ch
		if (ret == 0) {
    
			return <-ch_cfg, nil
		} else if (ret == 1) {
    
			go Read(filename, ch_cfg)
		}
	}
}

到这里还没有结束，很容易发现有一个问题：listen函数在finishRead为true时就向信道ch中传一个值0并return，但如果这发生在文件已经被修改过的情况下，第二个Read函数正在运行当中，运行结束的是第一个Read函数，会导致什么？

相当于返回的还是一个Read读到的内容，并没有读到文件修改后的最新信息。

所以需要对listen函数作一点修改，增加一个全局变量readCount，初始化为0。每次发现文件被修改时即将readCount的值加1，代表有一个新的线程正在读取文件，在finishRead为true时再加一层判断：如果readCount不为0，代表还有线程在读取文件，并且很有可能是文件被修改后才运行的线程，那么我们忽略这一次的finishRead，将readCount的值减1，finishRead设为false，等待最新的Read函数返回最新的iniCFG信息（这才是我们要的）。

修改后listen函数如下：

func (listener MyListener) listen(filename string, ch chan int ) {
    
	lastModTime := GetFileModTime(filename)
	for {
    
		
		modTime := GetFileModTime(filename)
		if (modTime != lastModTime) {
    
			lastModTime = modTime
			fmt.Print("fie changed, restart reading.\n")
			readCount++
			ch <- 1
			
		}
		if (finishRead) {
    
			if (readCount > 0) {
    //有新开的read 线程未结束
				readCount--
				finishRead = false
				continue
			}
			ch <- 0
			return
		}
	}
}

至此大致的思路就讲完啦。

三、测试

（一）测试文件

data.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

（二）测试代码

Section和iniCFG的测试较为简单，略过不讲。主要讲一下watch函数的测试（即包含了Read和listener两部分）。

比较两个iniCFG结构的不同，cfg0是运行watch函数读取filename对应文件得到的iniCFG结构，cfg则存储了预期的内容。

func TestRead(t *testing.T) {
    
	filename := "data.ini"
	var listener MyListener

	cfg0, err := Watch(filename, listener)
	if err != nil {
    
		t.Error(err)
	}

	cfg := NewIniCFG()
// app_mode
	sec := NewSection()
	cfg.mp[""] = sec
	sec.mp["app_mode"] = "development"
	//不能直接比较两个map是否相同，即使内部完全相同，也会因为地址不同而不同
	if (cfg.mp[""].mp["app_mode"] != cfg0.mp[""].mp["app_mode"]) {
    
		t.Errorf("want %v, got %v.",  cfg.mp[""].mp["app_mode"], cfg0.mp[""].mp["app_mode"] );
	}

//paths
	sec1 := NewSection()
	cfg.mp["paths"] = sec1
	sec1.mp["data"] = "/home/git/grafana"
	if (cfg.mp["paths"].mp["data"] != cfg0.mp["paths"].mp["data"]) {
    
		t.Errorf("want %v, got %v.",  cfg.mp["paths"].mp["data"] , cfg0.mp["paths"].mp["data"] );
	}

//server
	sec2 := NewSection()
	cfg.mp["server"] = sec2
	sec2.mp["enforce_domain"] = "true"
	if (cfg.mp["server"].mp["enforce_domain"] != cfg0.mp["server"].mp["enforce_domain"]) {
    
		t.Errorf("want %v, got %v.",  cfg.mp["server"].mp["enforce_domain"] , cfg0.mp["server"].mp["enforce_domain"] );
	}

//全部打印出来，用于快速人工检查
	// for key, value := range cfg0.mp {
    
	// 	fmt.Print(key)
	// 	fmt.Print(value)
	// }
	// t.Error(1)

}

（三）测试结果

首先是不阻塞读文件

由于读文件的速度太快，根本来不及在读文件过程中修改文件，所以为了测试listen的功能，我们在Read函数中每读一个字符就阻塞一下，利用time.Sleep()睡眠一段时间。

//下面一行只在测试时为了有充足时间修改文件才需要
time.Sleep(time.Duration(100) * time.Millisecond)

在命令行敲下命令运行go test后，打开data.ini文件，修改appmode，在development后加一个s，然后保存，切换到控制台等待程序运行结束。发现这样的结果：

如果得不到以上结果，可能是修改和保存文件的速度不够快，可以再手动调节一下读每个字符后的阻塞时间。

可以看到，watch函数在读的过程中能够通过listener监听文件的变化，如果文件被修改了，watch将读到修改后的文件内容。说明listener是可以与Read正常搭配工作的。

四、其他

（一）自定义错误

error.go中定义了SecNameDoesNotExist错误，在getSection() 中使用，当试图访问一个iniCFG结构中不存在的段时会返回这个错误。
定义这个错误的原因是如果不经判断地使用cfg.GetSection(sectionName).getValByKey(key)，当sectionName并不存在时，GetSection() 返回的是一个空指针，对空指针调用方法会导致空指针访问异常。

//SecNameDoesNotExist 自定义错误，当试图访问一个iniCFG中不存在的Section时返回
type SecNameDoesNotExist  struct {
    
	secName string
}
func (err SecNameDoesNotExist) Error() string {
    
	return fmt.Sprintf("Error: section %s does not exist!", err.secName)
}

（二）全局变量和init函数

注释符号默认为‘#’，在windows系统下变为’;’

//全局变量
var (
	commentSymbol byte = '#'
	finishRead = false
	readCount = 0
)

func init() {
    
	if runtime.GOOS == "windows" {
    
		commentSymbol = ';'
	}
}

（三）生成的中文API文档

请在包中查看。

（四）Readme文件

包含了一个如何使用这个包的例子。
请在包中查看。

五、项目地址

gitee链接