forked from cert-manager/cert-manager
-
Notifications
You must be signed in to change notification settings - Fork 0
/
util.go
242 lines (203 loc) · 6.01 KB
/
util.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
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
/*
Copyright 2020 The cert-manager Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package util
import (
"bytes"
"encoding/csv"
"fmt"
"math/rand"
"net"
"net/url"
"sort"
"strings"
"time"
cmapi "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1"
)
func OnlyOneNotNil(items ...interface{}) (any bool, one bool) {
oneNotNil := false
for _, i := range items {
if i != nil {
if oneNotNil {
return true, false
}
oneNotNil = true
}
}
return oneNotNil, oneNotNil
}
func EqualSorted(s1, s2 []string) bool {
if len(s1) != len(s2) {
return false
}
for i := range s1 {
if s1[i] != s2[i] {
return false
}
}
return true
}
func EqualUnsorted(s1 []string, s2 []string) bool {
if len(s1) != len(s2) {
return false
}
s1_2, s2_2 := make([]string, len(s1)), make([]string, len(s2))
copy(s1_2, s1)
copy(s2_2, s2)
sort.Strings(s1_2)
sort.Strings(s2_2)
for i, s := range s1_2 {
if s != s2_2[i] {
return false
}
}
return true
}
// Test for equal URL slices even if unsorted. Panics if any element is nil
func EqualURLsUnsorted(s1, s2 []*url.URL) bool {
if len(s1) != len(s2) {
return false
}
s1_2, s2_2 := make([]*url.URL, len(s1)), make([]*url.URL, len(s2))
copy(s1_2, s1)
copy(s2_2, s2)
sort.SliceStable(s1_2, func(i, j int) bool {
return s1_2[i].String() < s1_2[j].String()
})
sort.SliceStable(s2_2, func(i, j int) bool {
return s2_2[i].String() < s2_2[j].String()
})
for i, s := range s1_2 {
if s.String() != s2_2[i].String() {
return false
}
}
return true
}
// EqualIPsUnsorted checks if the given slices of IP addresses contain the same elements, even if in a different order
// BACKPORT: Changes to this function were backported into this branch to fix an IP address comparison bug, but
// this function was changed to use sort.Slice instead of https://pkg.go.dev/golang.org/x/exp/slices.Sort as we didn't
// previously depend on the slices package in this version of cert-manager
func EqualIPsUnsorted(s1, s2 []net.IP) bool {
if len(s1) != len(s2) {
return false
}
// Two IPv4 addresses can compare unequal with bytes.Equal which is why net.IP.Equal exists.
// We still want to sort the lists, though, and we don't want different representations of IPv4 addresses
// to be sorted differently. That can happen if one is stored as a 4-byte address while
// the other is stored as a 16-byte representation
// To avoid ambiguity, we ensure that only the 16-byte form is used for all addresses we work with.
s1_2, s2_2 := make([]net.IP, len(s1)), make([]net.IP, len(s2))
for i := 0; i < len(s1); i++ {
s1_2[i] = s1[i].To16()
s2_2[i] = s2[i].To16()
}
sort.Slice(s1_2, func(i int, j int) bool {
return bytes.Compare([]byte(s1_2[i]), []byte(s1_2[j])) <= 0
})
sort.Slice(s2_2, func(i int, j int) bool {
return bytes.Compare([]byte(s2_2[i]), []byte(s2_2[j])) <= 0
})
for i := 0; i < len(s1_2); i++ {
if !s1_2[i].Equal(s2_2[i]) {
return false
}
}
return true
}
// Test for equal KeyUsage slices even if unsorted
func EqualKeyUsagesUnsorted(s1, s2 []cmapi.KeyUsage) bool {
if len(s1) != len(s2) {
return false
}
s1_2, s2_2 := make([]string, len(s1)), make([]string, len(s2))
// we may want to implement a sort interface here instead of []byte conversion
for i := range s1 {
s1_2[i] = string(s1[i])
s2_2[i] = string(s2[i])
}
sort.SliceStable(s1_2, func(i, j int) bool {
return s1_2[i] < s1_2[j]
})
sort.SliceStable(s2_2, func(i, j int) bool {
return s2_2[i] < s2_2[j]
})
for i, s := range s1_2 {
if s != s2_2[i] {
return false
}
}
return true
}
func init() {
rand.Seed(time.Now().UnixNano())
}
var letterRunes = []rune("abcdefghijklmnopqrstuvwxyz")
func RandStringRunes(n int) string {
b := make([]rune, n)
for i := range b {
b[i] = letterRunes[rand.Intn(len(letterRunes))]
}
return string(b)
}
// Contains returns true if a string is contained in a string slice
func Contains(ss []string, s string) bool {
for _, v := range ss {
if v == s {
return true
}
}
return false
}
// Subset returns true if one slice is an unsorted subset of the first.
func Subset(set, subset []string) bool {
for _, s := range subset {
if !Contains(set, s) {
return false
}
}
return true
}
// JoinWithEscapeCSV returns the given list as a single line of CSV that
// is escaped with quotes if necessary
func JoinWithEscapeCSV(in []string) (string, error) {
b := new(bytes.Buffer)
writer := csv.NewWriter(b)
writer.Write(in)
writer.Flush()
if err := writer.Error(); err != nil {
return "", fmt.Errorf("failed to write %q as CSV: %w", in, err)
}
s := b.String()
// CSV writer adds a trailing new line, we need to clean it up
s = strings.TrimSuffix(s, "\n")
return s, nil
}
// SplitWithEscapeCSV parses the given input as a single line of CSV, which allows
// a comma-separated list of strings to be parsed while allowing commas to be present
// in each field. For example, a user can specify:
// "10 Downing Street, Westminster",Manchester
// to produce []string{"10 Downing Street, Westminster", "Manchester"}, keeping the comma
// in the first address. Empty lines or multiple CSV records are both rejected.
func SplitWithEscapeCSV(in string) ([]string, error) {
reader := csv.NewReader(strings.NewReader(in))
records, err := reader.ReadAll()
if err != nil {
return nil, fmt.Errorf("failed to parse %q as CSV: %w", in, err)
}
if len(records) == 0 {
return nil, fmt.Errorf("no values found after parsing %q", in)
} else if len(records) > 1 {
return nil, fmt.Errorf("refusing to use %q as input as it parses as multiple lines of CSV", in)
}
return records[0], nil
}