forked from openshift/origin
-
Notifications
You must be signed in to change notification settings - Fork 0
/
latest.go
167 lines (139 loc) · 5.41 KB
/
latest.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
package latest
import (
"fmt"
"strings"
"k8s.io/kubernetes/pkg/api"
kmeta "k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/util/sets"
"github.com/golang/glog"
_ "github.com/openshift/origin/pkg/api"
"github.com/openshift/origin/pkg/api/v1"
"github.com/openshift/origin/pkg/api/v1beta3"
)
// Version is the string that represents the current external default version.
const Version = "v1"
// OldestVersion is the string that represents the oldest server version supported,
// for client code that wants to hardcode the lowest common denominator.
const OldestVersion = "v1beta3"
// Versions is the list of versions that are recognized in code. The order provided
// may be assumed to be least feature rich to most feature rich, and clients may
// choose to prefer the latter items in the list over the former items when presented
// with a set of versions to choose.
var Versions = []string{"v1", "v1beta3"}
// Codec is the default codec for serializing output that should use
// the latest supported version. Use this Codec when writing to
// disk, a data store that is not dynamically versioned, or in tests.
// This codec can decode any object that OpenShift is aware of.
var Codec = v1.Codec
// accessor is the shared static metadata accessor for the API.
var accessor = kmeta.NewAccessor()
// ResourceVersioner describes a default versioner that can handle all types
// of versioning.
// TODO: when versioning changes, make this part of each API definition.
var ResourceVersioner runtime.ResourceVersioner = accessor
// SelfLinker can set or get the SelfLink field of all API types.
// TODO: when versioning changes, make this part of each API definition.
// TODO(lavalamp): Combine SelfLinker & ResourceVersioner interfaces, force all uses
// to go through the InterfacesFor method below.
var SelfLinker runtime.SelfLinker = accessor
// RESTMapper provides the default mapping between REST paths and the objects declared in api.Scheme and all known
// Kubernetes versions.
var RESTMapper kmeta.RESTMapper
// InterfacesFor returns the default Codec and ResourceVersioner for a given version
// string, or an error if the version is not known.
func InterfacesFor(version string) (*kmeta.VersionInterfaces, error) {
switch version {
case "v1beta3":
return &kmeta.VersionInterfaces{
Codec: v1beta3.Codec,
ObjectConvertor: api.Scheme,
MetadataAccessor: accessor,
}, nil
case "v1":
return &kmeta.VersionInterfaces{
Codec: v1.Codec,
ObjectConvertor: api.Scheme,
MetadataAccessor: accessor,
}, nil
default:
return nil, fmt.Errorf("unsupported storage version: %s (valid: %s)", version, strings.Join(Versions, ", "))
}
}
// originTypes are the hardcoded types defined by the OpenShift API.
var originTypes = sets.String{}
// UserResources are the resource names that apply to the primary, user facing resources used by
// client tools. They are in deletion-first order - dependent resources should be last.
var UserResources = []string{
"buildConfigs", "builds",
"imageStreams",
"deploymentConfigs", "replicationControllers",
"routes", "services",
"pods",
}
// OriginKind returns true if OpenShift owns the kind described in a given apiVersion.
func OriginKind(kind, apiVersion string) bool {
return originTypes.Has(kind)
}
func init() {
// this keeps us consistent with old code. We can decide if we want to expand our RESTMapper to cover
// api.RESTMapper, which is different than what you'd get from latest.
kubeMapper := api.RESTMapper
// list of versions we support on the server, in preferred order
versions := []string{"v1", "v1beta3"}
originMapper := kmeta.NewDefaultRESTMapper(
"",
versions,
func(version string) (*kmeta.VersionInterfaces, error) {
interfaces, err := InterfacesFor(version)
if err != nil {
return nil, err
}
return interfaces, nil
},
)
// the list of kinds that are scoped at the root of the api hierarchy
// if a kind is not enumerated here, it is assumed to have a namespace scope
kindToRootScope := map[string]bool{
"Status": true,
"Project": true,
"ProjectRequest": true,
"Image": true,
"User": true,
"Identity": true,
"UserIdentityMapping": true,
"Group": true,
"OAuthAccessToken": true,
"OAuthAuthorizeToken": true,
"OAuthClient": true,
"OAuthClientAuthorization": true,
"ClusterRole": true,
"ClusterRoleBinding": true,
"ClusterPolicy": true,
"ClusterPolicyBinding": true,
"ClusterNetwork": true,
"HostSubnet": true,
"NetNamespace": true,
}
// enumerate all supported versions, get the kinds, and register with the mapper how to address our resources
for _, version := range versions {
for kind, t := range api.Scheme.KnownTypes(version) {
if !strings.Contains(t.PkgPath(), "openshift/origin") {
if _, ok := kindToRootScope[kind]; !ok {
continue
}
}
originTypes.Insert(kind)
scope := kmeta.RESTScopeNamespace
_, found := kindToRootScope[kind]
if found || (strings.HasSuffix(kind, "List") && kindToRootScope[strings.TrimSuffix(kind, "List")]) {
scope = kmeta.RESTScopeRoot
}
glog.V(6).Infof("Registering %s %s %s", kind, version, scope.Name())
originMapper.Add(scope, kind, version, false)
}
}
// For Origin we use MultiRESTMapper that handles both Origin and Kubernetes
// objects
RESTMapper = kmeta.MultiRESTMapper{originMapper, kubeMapper}
}