/
resource_names.go
128 lines (106 loc) · 3.63 KB
/
resource_names.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
// Copyright 2021 Google LLC
//
// 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 fakekms
import (
"fmt"
"regexp"
)
const idPattern = "[a-zA-Z0-9_-]{1,63}"
var (
idRegexp = regexp.MustCompile(fmt.Sprintf("^%s$", idPattern))
locationRegexp = regexp.MustCompile("^projects/([^/]+)/locations/([^/]+)$")
keyRingRegexp = regexp.MustCompile(fmt.Sprintf("^(.*)/keyRings/(%s)$", idPattern))
cryptoKeyRegexp = regexp.MustCompile(fmt.Sprintf("^(.*)/cryptoKeys/(%s)$", idPattern))
cryptoKeyVersionRegexp = regexp.MustCompile(fmt.Sprintf("^(.*)/cryptoKeyVersions/(%s)$", idPattern))
)
// checkID returns InvalidArgument if the provided ID does not comply with the KMS
// ID naming rules.
func checkID(id string) error {
if !idRegexp.MatchString(id) {
return errInvalidArgument("invalid id: %s", id)
}
return nil
}
type locationName struct {
ProjectID, LocationID string
}
func parseLocationName(name string) (locationName, error) {
if m := locationRegexp.FindStringSubmatch(name); m != nil {
return locationName{ProjectID: m[1], LocationID: m[2]}, nil
}
return locationName{}, errMalformedName("location", name)
}
func (n locationName) Project() string {
return fmt.Sprintf("projects/%s", n.ProjectID)
}
func (n locationName) Location() string {
return fmt.Sprintf("projects/%s/locations/%s", n.ProjectID, n.LocationID)
}
func (n locationName) String() string {
return n.Location()
}
type keyRingName struct {
locationName
KeyRingID string
}
func parseKeyRingName(name string) (keyRingName, error) {
if m := keyRingRegexp.FindStringSubmatch(name); m != nil {
if loc, err := parseLocationName(m[1]); err == nil {
return keyRingName{locationName: loc, KeyRingID: m[2]}, nil
}
}
return keyRingName{}, errMalformedName("key ring", name)
}
func (n keyRingName) KeyRing() string {
return fmt.Sprintf("%s/keyRings/%s", n.Location(), n.KeyRingID)
}
func (n keyRingName) String() string {
return n.KeyRing()
}
type cryptoKeyName struct {
keyRingName
CryptoKeyID string
}
func parseCryptoKeyName(name string) (cryptoKeyName, error) {
if m := cryptoKeyRegexp.FindStringSubmatch(name); m != nil {
if kr, err := parseKeyRingName(m[1]); err == nil {
return cryptoKeyName{keyRingName: kr, CryptoKeyID: m[2]}, nil
}
}
return cryptoKeyName{}, errMalformedName("crypto key", name)
}
func (n cryptoKeyName) CryptoKey() string {
return fmt.Sprintf("%s/cryptoKeys/%s", n.KeyRing(), n.CryptoKeyID)
}
func (n cryptoKeyName) String() string {
return n.CryptoKey()
}
type cryptoKeyVersionName struct {
cryptoKeyName
CryptoKeyVersionID string
}
func parseCryptoKeyVersionName(name string) (cryptoKeyVersionName, error) {
if m := cryptoKeyVersionRegexp.FindStringSubmatch(name); m != nil {
if ck, err := parseCryptoKeyName(m[1]); err == nil {
return cryptoKeyVersionName{cryptoKeyName: ck, CryptoKeyVersionID: m[2]}, nil
}
}
return cryptoKeyVersionName{}, errMalformedName("crypto key version", name)
}
func (n cryptoKeyVersionName) CryptoKeyVersion() string {
return fmt.Sprintf("%s/cryptoKeyVersions/%s", n.CryptoKey(), n.CryptoKeyVersionID)
}
func (n cryptoKeyVersionName) String() string {
return n.CryptoKeyVersion()
}