go.temporal.io/server/common/config/loader.go
331 LOC · 130 covered · 201 uncovered · 52 ranges · 33 concepts · 19 introducers · 20 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
package config
2
3
import (
4
"bufio"
5
"bytes"
6
_ "embed"
7
"errors"
8
"fmt"
9
"io"
10
stdlog "log"
11
"os"
12
"path/filepath"
13
"strings"
14
"text/template"
15
16
"github.com/Masterminds/sprig/v3"
17
"gopkg.in/yaml.v3"
18
)
19
20
//go:embed config_template_embedded.yaml
21
var embeddedConfigTemplate []byte
22
23
var (
24
// ErrConfigFilesNotFound is returned when no config files are found in the specified directory
25
ErrConfigFilesNotFound = errors.New("no config files found")
26
)
27
28
const (
29
// EnvKeyRoot the environment variable key for runtime root dir
30
EnvKeyRoot = "TEMPORAL_ROOT"
31
// EnvKeyConfigDir the environment variable key for config dir
32
EnvKeyConfigDir = "TEMPORAL_CONFIG_DIR"
33
// EnvKeyEnvironment is the environment variable key for environment
34
EnvKeyEnvironment = "TEMPORAL_ENVIRONMENT"
35
// EnvKeyAvailabilityZone is the environment variable key for AZ
36
EnvKeyAvailabilityZone = "TEMPORAL_AVAILABILITY_ZONE"
37
// EnvKeyAvailabilityZoneTypo is the old environment variable key for AZ that
38
// included a typo. This is deprecated and only here to support backwards
39
// compatibility.
40
EnvKeyAvailabilityZoneTypo = "TEMPORAL_AVAILABILTY_ZONE"
41
// EnvKeyAllowNoAuth is the environment variable key for setting no authorizer
42
EnvKeyAllowNoAuth = "TEMPORAL_ALLOW_NO_AUTH"
43
// EnvKeyConfigFile is the environment variable key for specifying a config file path
44
EnvKeyConfigFile = "TEMPORAL_SERVER_CONFIG_FILE_PATH"
45
)
46
47
const (
48
baseFile = "base.yaml"
49
envDevelopment = "development"
50
defaultConfigDir = "config"
51
enableTemplate = "enable-template"
52
commentSearchLimit = 1024
53
)
54
55
// Load loads the configuration from a set of
56
// yaml config files found in the config directory
57
//
58
// The loader first fetches the set of files matching
59
// a pre-determined naming convention, then sorts
60
// them by hierarchy order and after that, simply
61
type loadOptions struct {
62
env string
63
configDir string
64
zone string
65
configFilePath string
66
useEmbeddedOnly bool
67
}
68
69
type loadOption func(*loadOptions)
70
71
// WithEnv sets the environment name for configuration loading (e.g., "development", "production").
72
// If empty, defaults to "development".
74
>
return func(o *loadOptions) {
75
>
if env != "" {
77
>
}
78
}
79
}
80
81
// WithConfigDir sets the directory path where configuration files are located.
82
// If empty, defaults to "config".
84
>
return func(o *loadOptions) {
85
>
if configDir != "" {
86
>
o.configDir = configDir
87
>
}
88
}
89
}
90
91
// WithZone sets the availability zone for configuration loading.
92
// This is used to load zone-specific configuration overrides (e.g., "us-east-1a").
94
>
return func(o *loadOptions) {
95
>
if zone != "" {
97
>
}
98
}
99
}
100
101
// WithConfigFile sets a specific configuration file path to load.
102
// When provided, only this file will be loaded, bypassing the legacy hierarchical loading.
104
>
return func(o *loadOptions) {
105
>
if configFilePath != "" {
106
>
o.configFilePath = configFilePath
107
>
}
108
}
109
}
110
111
// WithEmbedded forces the loader to use only the embedded configuration template.
112
// This loads configuration from environment variables only, using the embedded template.
113
func WithEmbedded() loadOption {
114
return func(o *loadOptions) {
115
o.useEmbeddedOnly = true
116
}
117
}
118
119
// Load loads and validates the Temporal server configuration.
120
// It supports multiple loading strategies based on the provided options:
121
// - Embedded template with environment variables (WithEmbedded)
122
// - Single config file (WithConfigFile)
123
// - Legacy hierarchical config directory (WithConfigDir, WithEnv, WithZone)
124
//
125
// Configuration files can be templated using Go template syntax with sprig-compatible
126
// functions. To enable templating, add "# enable-template" comment in the first 1KB of the file.
127
//
128
// Returns the loaded configuration or an error if loading or validation fails.
130
>
cfg := &Config{}
131
>
options := &loadOptions{}
132
>
133
>
for _, opt := range opts {
134
>
opt(options)
135
>
}
136
139
>
}
141
}
142
144
>
145
>
if opts.useEmbeddedOnly {
146
stdlog.Println("Loading configuration from environment variables only")
147
return loadAndUnmarshalContent(embeddedConfigTemplate, "config_template_embedded.yaml", config)
148
}
149
152
>
if err != nil {
154
>
}
155
>
return loadAndUnmarshalContent(content, filepath.Base(opts.configFilePath), config)
loader.go ×8
156
}
158
159
}
160
161
// loadLegacy loads configuration data from a set of YAML files
162
// located in the config directory.
163
//
164
// Deprecated: This loader is maintained only for backward compatibility
165
// and should not be used in new code.
166
//
167
// The loader first identifies all files matching a predefined
168
// naming convention, then sorts them according to their hierarchy.
169
// It then loads the files sequentially, with key/value pairs in
170
// later files overriding those in earlier ones.
171
//
172
// The hierarchy, from lowest to highest precedence, is as follows:
173
//
174
// base.yaml
175
// env.yaml -- where "environment" is one of the input parameters (e.g., "development")
176
// env_az.yaml -- where "zone" is another input parameter
177
179
>
stdlog.Printf("Loading config; env=%v,zone=%v,configDir=%v\n", opts.env, opts.zone, opts.configDir)
180
>
if opts.env == "" {
182
>
}
184
opts.configDir = defaultConfigDir
185
}
186
187
>
stdlog.Printf("Loading config; env=%v,zone=%v,configDir=%v\n", opts.env, opts.zone, opts.configDir)
loader.go ×9
188
>
189
>
files, err := getConfigFiles(opts.env, opts.configDir, opts.zone)
190
>
if err != nil {
192
>
}
193
195
>
196
>
for _, f := range files {
197
>
data, err := readConfigFile(f)
198
>
if err != nil {
199
return err
200
}
201
203
>
if err != nil {
204
return err
205
}
206
208
>
if err != nil {
210
>
}
211
}
212
214
>
return validate.Validate(config)
215
}
216
218
>
data, err := os.ReadFile(path)
219
>
if err != nil {
221
>
222
>
}
224
}
225
226
// processConfigFile processes a config file, rendering it as a template if enabled
228
>
// If the config file contains "enable-template" in a comment within the first 1KB, then
229
>
// we will treat the file as a template and render it.
230
>
templating, err := checkTemplatingEnabled(data)
231
>
if err != nil {
232
return nil, err
233
}
234
237
>
}
238
240
>
tpl, err := template.New(filename).Funcs(sprig.FuncMap()).Parse(string(data))
241
>
if err != nil {
242
return nil, err
243
}
244
246
>
err = tpl.Execute(&rendered, nil)
247
>
if err != nil {
248
return nil, err
249
}
250
252
}
253
254
>
func loadAndUnmarshalContent(content []byte, filename string, config any) error {
loader.go ×8
255
>
processed, err := processConfigFile(content, filename)
256
>
if err != nil {
257
return fmt.Errorf("failed to process config file %s: %w", filename, err)
258
}
259
261
return fmt.Errorf("failed to unmarshal config file %s: %w", filename, err)
262
}
263
265
>
return validate.Validate(config)
266
}
267
269
>
scanner := bufio.NewScanner(io.LimitReader(bytes.NewReader(content), commentSearchLimit))
270
>
for scanner.Scan() {
271
>
line := strings.TrimSpace(scanner.Text())
272
>
273
>
if strings.HasPrefix(line, "#") && strings.Contains(line, enableTemplate) {
275
>
}
276
}
277
279
}
280
281
// getConfigFiles returns the list of config files to
282
// process in the hierarchy order
283
>
func getConfigFiles(env string, configDir string, zone string) ([]string, error) {
loader.go ×9
284
>
candidates := make([]string, 2, 3)
285
>
candidates[0] = filepath.Join(configDir, baseFile)
286
>
candidates[1] = filepath.Join(configDir, file(env, "yaml"))
287
>
288
>
if zone != "" {
290
>
candidates = append(candidates, filepath.Join(configDir, f))
291
>
}
292
294
>
295
>
for _, c := range candidates {
296
>
_, err := os.Stat(c)
297
>
if errors.Is(err, os.ErrNotExist) {
299
}
301
return nil, fmt.Errorf("error accessing config file %s: %w", c, err)
302
}
304
}
307
>
}
308
310
}
311
313
>
return a + "_" + b
314
>
}
315
317
>
return name + "." + suffix
318
>
}
319
320
func loadEnvMap() map[string]string {
321
environ := os.Environ()
322
envMap := make(map[string]string, len(environ))
323
324
for _, env := range environ {
325
key, value, found := strings.Cut(env, "=")
326
if found && key != "" {
327
envMap[key] = value
328
}
329
}
330
return envMap
331
}