-
Notifications
You must be signed in to change notification settings - Fork 0
/
gcfg.go
200 lines (181 loc) · 6.15 KB
/
gcfg.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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/joy12825/gf.
// Package gcfg provides reading, caching and managing for configuration.
package gcfg
import (
"context"
"github.com/joy12825/gf/container/gvar"
"github.com/joy12825/gf/errors/gcode"
"github.com/joy12825/gf/errors/gerror"
"github.com/joy12825/gf/internal/command"
"github.com/joy12825/gf/internal/intlog"
"github.com/joy12825/gf/internal/utils"
"github.com/joy12825/gf/os/genv"
)
// Config is the configuration management object.
type Config struct {
adapter Adapter
}
const (
DefaultInstanceName = "config" // DefaultName is the default instance name for instance usage.
DefaultConfigFileName = "config" // DefaultConfigFile is the default configuration file name.
)
// New creates and returns a Config object with default adapter of AdapterFile.
func New() (*Config, error) {
adapterFile, err := NewAdapterFile()
if err != nil {
return nil, err
}
return &Config{
adapter: adapterFile,
}, nil
}
// NewWithAdapter creates and returns a Config object with given adapter.
func NewWithAdapter(adapter Adapter) *Config {
return &Config{
adapter: adapter,
}
}
// Instance returns an instance of Config with default settings.
// The parameter `name` is the name for the instance. But very note that, if the file "name.toml"
// exists in the configuration directory, it then sets it as the default configuration file. The
// toml file type is the default configuration file type.
func Instance(name ...string) *Config {
var instanceName = DefaultInstanceName
if len(name) > 0 && name[0] != "" {
instanceName = name[0]
}
return localInstances.GetOrSetFuncLock(instanceName, func() interface{} {
adapterFile, err := NewAdapterFile()
if err != nil {
intlog.Errorf(context.Background(), `%+v`, err)
return nil
}
if instanceName != DefaultInstanceName {
adapterFile.SetFileName(instanceName)
}
return NewWithAdapter(adapterFile)
}).(*Config)
}
// SetAdapter sets the adapter of current Config object.
func (c *Config) SetAdapter(adapter Adapter) {
c.adapter = adapter
}
// GetAdapter returns the adapter of current Config object.
func (c *Config) GetAdapter() Adapter {
return c.adapter
}
// Available checks and returns the configuration service is available.
// The optional parameter `pattern` specifies certain configuration resource.
//
// It returns true if configuration file is present in default AdapterFile, or else false.
// Note that this function does not return error as it just does simply check for backend configuration service.
func (c *Config) Available(ctx context.Context, resource ...string) (ok bool) {
return c.adapter.Available(ctx, resource...)
}
// Get retrieves and returns value by specified `pattern`.
// It returns all values of current Json object if `pattern` is given empty or string ".".
// It returns nil if no value found by `pattern`.
//
// It returns a default value specified by `def` if value for `pattern` is not found.
func (c *Config) Get(ctx context.Context, pattern string, def ...interface{}) (*gvar.Var, error) {
var (
err error
value interface{}
)
value, err = c.adapter.Get(ctx, pattern)
if err != nil {
return nil, err
}
if value == nil {
if len(def) > 0 {
return gvar.New(def[0]), nil
}
return nil, nil
}
return gvar.New(value), nil
}
// GetWithEnv returns the configuration value specified by pattern `pattern`.
// If the configuration value does not exist, then it retrieves and returns the environment value specified by `key`.
// It returns the default value `def` if none of them exists.
//
// Fetching Rules: Environment arguments are in uppercase format, eg: GF_PACKAGE_VARIABLE.
func (c *Config) GetWithEnv(ctx context.Context, pattern string, def ...interface{}) (*gvar.Var, error) {
value, err := c.Get(ctx, pattern)
if err != nil && gerror.Code(err) != gcode.CodeNotFound {
return nil, err
}
if value == nil {
if v := genv.Get(utils.FormatEnvKey(pattern)); v != nil {
return v, nil
}
if len(def) > 0 {
return gvar.New(def[0]), nil
}
return nil, nil
}
return value, nil
}
// GetWithCmd returns the configuration value specified by pattern `pattern`.
// If the configuration value does not exist, then it retrieves and returns the command line option specified by `key`.
// It returns the default value `def` if none of them exists.
//
// Fetching Rules: Command line arguments are in lowercase format, eg: gf.package.variable.
func (c *Config) GetWithCmd(ctx context.Context, pattern string, def ...interface{}) (*gvar.Var, error) {
value, err := c.Get(ctx, pattern)
if err != nil && gerror.Code(err) != gcode.CodeNotFound {
return nil, err
}
if value == nil {
if v := command.GetOpt(utils.FormatCmdKey(pattern)); v != "" {
return gvar.New(v), nil
}
if len(def) > 0 {
return gvar.New(def[0]), nil
}
return nil, nil
}
return value, nil
}
// Data retrieves and returns all configuration data as map type.
func (c *Config) Data(ctx context.Context) (data map[string]interface{}, err error) {
return c.adapter.Data(ctx)
}
// MustGet acts as function Get, but it panics if error occurs.
func (c *Config) MustGet(ctx context.Context, pattern string, def ...interface{}) *gvar.Var {
v, err := c.Get(ctx, pattern, def...)
if err != nil {
panic(err)
}
if v == nil {
return nil
}
return v
}
// MustGetWithEnv acts as function GetWithEnv, but it panics if error occurs.
func (c *Config) MustGetWithEnv(ctx context.Context, pattern string, def ...interface{}) *gvar.Var {
v, err := c.GetWithEnv(ctx, pattern, def...)
if err != nil {
panic(err)
}
return v
}
// MustGetWithCmd acts as function GetWithCmd, but it panics if error occurs.
func (c *Config) MustGetWithCmd(ctx context.Context, pattern string, def ...interface{}) *gvar.Var {
v, err := c.GetWithCmd(ctx, pattern, def...)
if err != nil {
panic(err)
}
return v
}
// MustData acts as function Data, but it panics if error occurs.
func (c *Config) MustData(ctx context.Context) map[string]interface{} {
v, err := c.Data(ctx)
if err != nil {
panic(err)
}
return v
}