/
identity.go
146 lines (119 loc) · 3.05 KB
/
identity.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
package identity
import (
"fmt"
proto "github.com/golang/protobuf/proto"
"github.com/hashicorp/errwrap"
"github.com/hashicorp/vault/sdk/logical"
)
func (g *Group) Clone() (*Group, error) {
if g == nil {
return nil, fmt.Errorf("nil group")
}
marshaledGroup, err := proto.Marshal(g)
if err != nil {
return nil, errwrap.Wrapf("failed to marshal group: {{err}}", err)
}
var clonedGroup Group
err = proto.Unmarshal(marshaledGroup, &clonedGroup)
if err != nil {
return nil, errwrap.Wrapf("failed to unmarshal group: {{err}}", err)
}
return &clonedGroup, nil
}
func (e *Entity) Clone() (*Entity, error) {
if e == nil {
return nil, fmt.Errorf("nil entity")
}
marshaledEntity, err := proto.Marshal(e)
if err != nil {
return nil, errwrap.Wrapf("failed to marshal entity: {{err}}", err)
}
var clonedEntity Entity
err = proto.Unmarshal(marshaledEntity, &clonedEntity)
if err != nil {
return nil, errwrap.Wrapf("failed to unmarshal entity: {{err}}", err)
}
return &clonedEntity, nil
}
func (p *Alias) Clone() (*Alias, error) {
if p == nil {
return nil, fmt.Errorf("nil alias")
}
marshaledAlias, err := proto.Marshal(p)
if err != nil {
return nil, errwrap.Wrapf("failed to marshal alias: {{err}}", err)
}
var clonedAlias Alias
err = proto.Unmarshal(marshaledAlias, &clonedAlias)
if err != nil {
return nil, errwrap.Wrapf("failed to unmarshal alias: {{err}}", err)
}
return &clonedAlias, nil
}
// ToSDKAlias converts the provided alias to an SDK compatible alias.
func ToSDKAlias(a *Alias) *logical.Alias {
if a == nil {
return nil
}
metadata := make(map[string]string, len(a.Metadata))
for k, v := range a.Metadata {
metadata[k] = v
}
return &logical.Alias{
Name: a.Name,
ID: a.ID,
MountAccessor: a.MountAccessor,
MountType: a.MountType,
Metadata: metadata,
NamespaceID: a.NamespaceID,
}
}
// ToSDKEntity converts the provided entity to an SDK compatible entity.
func ToSDKEntity(e *Entity) *logical.Entity {
if e == nil {
return nil
}
aliases := make([]*logical.Alias, len(e.Aliases))
for i, a := range e.Aliases {
aliases[i] = ToSDKAlias(a)
}
metadata := make(map[string]string, len(e.Metadata))
for k, v := range e.Metadata {
metadata[k] = v
}
return &logical.Entity{
ID: e.ID,
Name: e.Name,
Disabled: e.Disabled,
Aliases: aliases,
Metadata: metadata,
NamespaceID: e.NamespaceID,
}
}
// ToSDKGroup converts the provided group to an SDK compatible group.
func ToSDKGroup(g *Group) *logical.Group {
if g == nil {
return nil
}
metadata := make(map[string]string, len(g.Metadata))
for k, v := range g.Metadata {
metadata[k] = v
}
return &logical.Group{
ID: g.ID,
Name: g.Name,
Metadata: metadata,
NamespaceID: g.NamespaceID,
}
}
// ToSDKGroups converts the provided group list to an SDK compatible group list.
func ToSDKGroups(groups []*Group) []*logical.Group {
if groups == nil {
return nil
}
ret := make([]*logical.Group, len(groups))
for i, g := range groups {
ret[i] = ToSDKGroup(g)
}
return ret
}