/
conf.go
123 lines (105 loc) · 2.82 KB
/
conf.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
package main
import (
"bitbucket.org/liamstask/goose/lib/goose"
"errors"
"fmt"
"github.com/kylelemons/go-gypsy/yaml"
"os"
"path/filepath"
)
// Load config from specified YAML file.
func loadConfig() (confs []*goose.DBConf, err error) {
// migrationsDir should be placed at conf directory
migrationsDir := filepath.Dir(prmConfPath) + "/" + prmGroup
f, err := yaml.ReadFile(prmConfPath)
if err != nil {
return nil, err
}
rootMap, err := nodeToMap(f.Root)
if err != nil {
return nil, errors.New(fmt.Sprintf("conf file syntax is not valid"))
}
confNodes, err := nodeToList(rootMap[prmGroup])
if err != nil {
return nil, errors.New(fmt.Sprintf(`group "%s" is not found on %s`, prmGroup, prmConfPath))
}
confs = make([]*goose.DBConf, 0, confNodes.Len())
for i, confNode := range confNodes {
conf, err := nodeToMap(confNode)
if err != nil {
return nil, err
}
drvNode, err := yaml.Child(conf, "driver")
if err != nil {
return nil, errors.New(fmt.Sprintf(`%s[%d]: required item "driver" is missing `, prmGroup, i))
}
drv, err := nodeToString(drvNode)
if err != nil {
return nil, err
}
drv = os.ExpandEnv(drv)
openNode, err := yaml.Child(conf, "open")
if err != nil {
return nil, errors.New(fmt.Sprintf(`%s[%d]: required item "open" is missing`, prmGroup, i))
}
open, err := nodeToString(openNode)
if err != nil {
return nil, err
}
open = os.ExpandEnv(open)
d, err := newDBDriver(drv, open)
if err != nil {
return nil, err
}
if !d.IsValid() {
return nil, errors.New(fmt.Sprintf("Invalid DBConf: %v", d))
}
confs = append(confs, &goose.DBConf{
MigrationsDir: migrationsDir,
Env: fmt.Sprintf("%s[%d]", prmGroup, i),
Driver: d,
})
}
return confs, nil
}
// Create a new DBDriver and populate driver specific
// fields for drivers that we know about.
// Further customization may be done in NewDBConf
func newDBDriver(name, open string) (goose.DBDriver, error) {
d := goose.DBDriver{
Name: name,
OpenStr: open,
}
// currently only support mysql
switch name {
case "mysql":
d.Import = "github.com/go-sql-driver/mysql"
d.Dialect = &goose.MySqlDialect{}
return d, nil
}
return d, errors.New("driver name is not valid")
}
// Cast YAML Node to Map
func nodeToMap(node yaml.Node) (yaml.Map, error) {
m, ok := node.(yaml.Map)
if !ok {
return nil, errors.New(fmt.Sprintf("%v is not of type map", node))
}
return m, nil
}
// Cast YAML Node to List
func nodeToList(node yaml.Node) (yaml.List, error) {
m, ok := node.(yaml.List)
if !ok {
return nil, errors.New(fmt.Sprintf("%v is not of type list", node))
}
return m, nil
}
// Cast YAML Node to string
func nodeToString(node yaml.Node) (string, error) {
m, ok := node.(yaml.Scalar)
if !ok {
return "", errors.New(fmt.Sprintf("%v is not of type scalar", node))
}
return m.String(), nil
}