This repository was archived by the owner on Sep 6, 2022. It is now read-only.
Repository navigation
Expand file tree
/
Copy pathenvar.go
More file actions
145 lines (131 loc) · 3.5 KB
/
Copy pathenvar.go
File metadata and controls
145 lines (131 loc) · 3.5 KB
1
2
3
4
5
6
7
8<
8000
/div>
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
package merge
/*
Onix Config Manager - Artisan
Copyright (c) 2018-Present by www.gatblau.org
Licensed under the Apache License, Version 2.0 at http://www.apache.org/licenses/LICENSE-2.0
Contributors to this project, hereby assign copyright in this code to the project,
to be licensed under the same terms as the rest of the code.
*/
import (
"bytes"
"fmt"
"github.com/gatblau/onix/artisan/core"
"io/ioutil"
"reflect"
"strconv"
"strings"
)
type Envar struct {
Vars map[string]string
}
// Group used by golang text.Template to return a map of key / values for vars that whose base name is the same
// but have been suffixed with an incremental index number
func (e *Envar) Group(groupName reflect.Value) reflect.Value {
result := make(map[string]string)
for name, value := range e.Vars {
i := strings.LastIndex(name, "_")
if i > 0 {
prefix := name[0:i]
suffix := name[i+1 : len(name)]
_, err := strconv.ParseInt(suffix, 10, 16)
// if the parsing works it is an index
if err == nil && prefix == groupName.String() {
result[name] = value
}
}
}
return reflect.ValueOf(result)
}
func NewEnVarFromMap(v map[string]string) *Envar {
return &Envar{
Vars: v,
}
}
func NewEnVarFromFile(envFile string) (*Envar, error) {
var outMap = make(map[string]string)
file := core.ToAbs(envFile)
data, err := ioutil.ReadFile(file)
// if it managed to find the env file load it
// otherwise skip it
content := strings.Split(string(data), "\n")
if err == nil {
for _, line := range content {
// skips comments
if strings.HasPrefix(strings.Trim(line, " "), "#") ||
len(strings.Trim(line, " ")) == 0 ||
strings.HasPrefix(strings.Trim(line, " "), "\r") ||
strings.HasPrefix(strings.Trim(line, " "), "\n") {
continue
}
// Splitting exactly on 2 strings
// example: VAR=test= Result: val[0] is VAR val[1] is test=
// Required for cases where value contains = sign like base64 values
keyValue := strings.SplitN(line, "=", 2)
outMap[keyValue[0]] = removeTrail(keyValue[1])
}
} else {
core.Debug("cannot load env file: %s", err.Error())
}
core.Debug("loaded environment file: %s\n", envFile)
return &Envar{
Vars: outMap,
}, nil
}
// remove trailing \r or \n or \r\n
func removeTrail(value string) string {
// case 1 => \r
// case 2 => \n
// case 3 => \r\n
value = strings.Trim(value, "\r")
value = strings.Trim(value, "\n")
value = strings.Trim(value, "\r")
return value
}
func NewEnVarFromSlice(v []string) *Envar {
ev := &Envar{
Vars: make(map[string]string),
}
for _, s := range v {
kv := strings.SplitN(s, "=", 2)
ev.Add(kv[0], kv[1])
}
return ev
}
func (e *Envar) Add(key, value string) {
e.Vars[key] = value
}
func (e *Envar) Slice() []string {
var result []string
for k, v := range e.Vars {
result = append(result, fmt.Sprintf("%s=%s", k, v))
}
return result
}
func (e *Envar) Append(v map[string]string) *Envar {
var result = make(map[string]string)
result = e.Vars
for k, v := range v {
result[k] = v
}
return NewEnVarFromMap(result)
}
func (e *Envar) Merge(env *Envar) {
for key, value := range env.Vars {
e.Vars[key] = value
}
}
func (e *Envar) String() string {
buffer := bytes.Buffer{}
for key, value := range e.Vars {
buffer.WriteString(fmt.Sprintf("%s=%s\n", key, value))
}
return buffer.String()
}
func (e *Envar) Debug(processName string) {
if core.InDebugMode() {
core.DebugLogger.Printf("%s => environment variables:\n", processName)
for key, value := range e.Vars {
core.DebugLogger.Printf("%s=%s\n", key, value)
}
}
}