github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2026-01-05 15:37:24 +00:00
Code Issues Projects Releases Wiki Activity

Refactor the API registration and installation

Browse Source
This commit is contained in:
Chao Xu
2015-12-18 21:08:34 -08:00
parent be235e8754
commit 2b5b708b70
30 changed files with 332 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
pkg/api/install/install.go
View File

@@ -25,10 +25,10 @@ import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/latest"
"k8s.io/kubernetes/pkg/api/registered"
"k8s.io/kubernetes/pkg/util/sets"
"k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/registered"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/api/v1"
"k8s.io/kubernetes/pkg/runtime"
@@ -42,20 +42,32 @@ var accessor = meta.NewAccessor()
var availableVersions = []unversioned.GroupVersion{v1.SchemeGroupVersion}
func init() {
registered.RegisterVersions(availableVersions...)
externalVersions := []unversioned.GroupVersion{}
for _, allowedVersion := range registered.GroupVersionsForGroup(api.GroupName) {
for _, externalVersion := range availableVersions {
if externalVersion == allowedVersion {
externalVersions = append(externalVersions, externalVersion)
}
for _, v := range availableVersions {
if registered.IsAllowedVersion(v) {
externalVersions = append(externalVersions, v)
}
}
if len(externalVersions) == 0 {
glog.V(4).Infof("No version is registered for group %v", api.GroupName)
return
}
if err := registered.EnableVersions(externalVersions...); err != nil {
glog.V(4).Infof("%v", err)
return
}
if err := enableVersions(externalVersions); err != nil {
glog.V(4).Infof("%v", err)
return
}
}
// TODO: enableVersions should be centralized rather than spread in each API
// group.
func enableVersions(externalVersions []unversioned.GroupVersion) error {
addVersionsToScheme(externalVersions...)
preferredExternalVersion := externalVersions[0]
groupMeta := latest.GroupMeta{
@@ -68,11 +80,10 @@ func init() {
}
if err := latest.RegisterGroup(groupMeta); err != nil {
glog.V(4).Infof("%v", err)
return
return err
}
api.RegisterRESTMapper(groupMeta.RESTMapper)
return nil
}
// userResources is a group of resources mostly used by a kubectl user
@@ -128,3 +139,19 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
}
}
func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
// add the internal version to Scheme
api.AddToScheme()
// add the enabled external versions to Scheme
for _, v := range externalVersions {
if !registered.IsEnabledVersion(v) {
glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
continue
}
switch v {
case v1.SchemeGroupVersion:
v1.AddToScheme()
}
}
}

4
pkg/api/register.go
View File

@@ -41,7 +41,7 @@ func Resource(resource string) unversioned.GroupResource {
return SchemeGroupVersion.WithResource(resource).GroupResource()
}
func init() {
func AddToScheme() {
Scheme.AddKnownTypes(SchemeGroupVersion,
&Pod{},
&PodList{},
@@ -86,7 +86,7 @@ func init() {
&RangeAllocation{},
)
// Register Unversioned types
// Add the Unversioned types to Scheme.
// TODO this should not be done here
Scheme.AddKnownTypes(SchemeGroupVersion, &unversioned.ExportOptions{})
Scheme.AddKnownTypes(SchemeGroupVersion, &unversioned.Status{})

161
pkg/api/registered/registered.go
View File

@@ -18,6 +18,7 @@ limitations under the License.
package registered
import (
"fmt"
"os"
"strings"
@@ -25,71 +26,129 @@ import (
"k8s.io/kubernetes/pkg/api/unversioned"
)
// List of registered API versions.
// The list is in the order of most preferred to the least.
var RegisteredGroupVersions []unversioned.GroupVersion
var (
// registeredVersions represents all registered API versions. Please call
// RegisterVersions() to add registered versions.
registeredVersions = map[unversioned.GroupVersion]struct{}{}
// enabledVersions represents all enabled API versions. It should be a
// subset of registeredVersions. Please call EnableVersions() to add
// enabled versions.
enabledVersions = map[unversioned.GroupVersion]struct{}{}
// envRequestedVersions represents the versions requested via the
// KUBE_API_VERSIONS environment variable. The install package of each group
// checks this list before add their versions to the latest package and
// Scheme.
envRequestedVersions = map[unversioned.GroupVersion]struct{}{}
)
func init() {
validGroupVersions := map[unversioned.GroupVersion]bool{
unversioned.GroupVersion{Group: "", Version: "v1"}: true,
unversioned.GroupVersion{Group: "extensions", Version: "v1beta1"}: true,
unversioned.GroupVersion{Group: "componentconfig", Version: "v1alpha1"}: true,
unversioned.GroupVersion{Group: "metrics", Version: "v1alpha1"}: true,
}
// The default list of supported api versions, in order of most preferred to the least.
supportedVersions := []unversioned.GroupVersion{
{Group: "", Version: "v1"},
{Group: "extensions", Version: "v1beta1"},
{Group: "componentconfig", Version: "v1alpha1"},
}
// Env var KUBE_API_VERSIONS is a comma separated list of API versions that should be registered in the scheme.
// The versions should be in the order of most preferred to the least.
userRequestedVersions := os.Getenv("KUBE_API_VERSIONS")
if len(userRequestedVersions) != 0 {
// reset the supported versions
supportedVersions = []unversioned.GroupVersion{}
for _, version := range strings.Split(userRequestedVersions, ",") {
// Env var KUBE_API_VERSIONS is a comma separated list of API versions that
// should be registered in the scheme.
kubeAPIVersions := os.Getenv("KUBE_API_VERSIONS")
if len(kubeAPIVersions) != 0 {
for _, version := range strings.Split(kubeAPIVersions, ",") {
gv, err := unversioned.ParseGroupVersion(version)
if err != nil {
glog.Fatalf("invalid api version: %s in KUBE_API_VERSIONS: %s. List of valid API versions: %v",
version, os.Getenv("KUBE_API_VERSIONS"), validGroupVersions)
glog.Fatalf("invalid api version: %s in KUBE_API_VERSIONS: %s.",
version, os.Getenv("KUBE_API_VERSIONS"))
}
// Verify that the version is valid.
valid, ok := validGroupVersions[gv]
if !ok || !valid {
// Not a valid API version.
glog.Fatalf("invalid api version: %s in KUBE_API_VERSIONS: %s. List of valid API versions: %v",
version, os.Getenv("KUBE_API_VERSIONS"), validGroupVersions)
}
supportedVersions = append(supportedVersions, gv)
envRequestedVersions[gv] = struct{}{}
}
}
RegisteredGroupVersions = supportedVersions
}
// Returns true if the given api version is one of the registered api versions.
func IsRegisteredAPIGroupVersion(gv unversioned.GroupVersion) bool {
for _, currGV := range RegisteredGroupVersions {
if currGV == gv {
return true
}
// RegisterVersions add the versions the registeredVersions.
func RegisterVersions(versions ...unversioned.GroupVersion) {
for _, v := range versions {
registeredVersions[v] = struct{}{}
}
return false
}
// GroupVersionsForGroup returns the registered versions of a group in the form
// of "group/version".
func GroupVersionsForGroup(group string) []unversioned.GroupVersion {
ret := []unversioned.GroupVersion{}
for _, v := range RegisteredGroupVersions {
// EnableVersions add the versions to the enabledVersions. The caller of this
// function is responsible to add the version to 'latest' and 'Scheme'.
func EnableVersions(versions ...unversioned.GroupVersion) error {
var unregisteredVersions []unversioned.GroupVersion
for _, v := range versions {
if _, found := registeredVersions[v]; !found {
unregisteredVersions = append(unregisteredVersions, v)
}
enabledVersions[v] = struct{}{}
}
if len(unregisteredVersions) != 0 {
return fmt.Errorf("Please register versions before enabling them: %v", unregisteredVersions)
}
return nil
}
// IsAllowedVersion returns if the version is allowed by the KUBE_API_VERSIONS
// environment variable. If the environment variable is empty, then it always
// returns true.
func IsAllowedVersion(v unversioned.GroupVersion) bool {
if len(envRequestedVersions) == 0 {
return true
}
_, found := envRequestedVersions[v]
return found
}
// IsEnabledVersion returns if a version is enabled.
func IsEnabledVersion(v unversioned.GroupVersion) bool {
_, found := enabledVersions[v]
return found
}
// IsRegisteredVersion returns if a version is registered.
func IsRegisteredVersion(v unversioned.GroupVersion) bool {
_, found := registeredVersions[v]
return found
}
// EnabledVersions returns all enabled versions.
func EnabledVersions() (ret []unversioned.GroupVersion) {
for v := range enabledVersions {
ret = append(ret, v)
}
return
}
// RegisteredVersions returns all registered versions.
func RegisteredVersions() (ret []unversioned.GroupVersion) {
for v := range registeredVersions {
ret = append(ret, v)
}
return
}
// EnabledVersionsForGroup returns all enabled versions for a group.
func EnabledVersionsForGroup(group string) (ret []unversioned.GroupVersion) {
for v := range enabledVersions {
if v.Group == group {
ret = append(ret, v)
}
}
return ret
return
}
// RegisteredVersionsForGroup returns all registered versions for a group.
func RegisteredVersionsForGroup(group string) (ret []unversioned.GroupVersion) {
for v := range registeredVersions {
if v.Group == group {
ret = append(ret, v)
}
}
return
}
// ValidateEnvRequestedVersions returns a list of versions that are requested in
// the KUBE_API_VERSIONS environment variable, but not enabled.
func ValidateEnvRequestedVersions() []unversioned.GroupVersion {
var missingVersions []unversioned.GroupVersion
for v := range envRequestedVersions {
if _, found := enabledVersions[v]; !found {
missingVersions = append(missingVersions, v)
}
}
return missingVersions
}

7
pkg/api/testing/fuzzer.go
View File

@@ -25,8 +25,8 @@ import (
docker "github.com/fsouza/go-dockerclient"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/registered"
"k8s.io/kubernetes/pkg/api/resource"
"k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/fields"
@@ -311,7 +311,10 @@ func FuzzerFor(t *testing.T, version string, src rand.Source) *fuzz.Fuzzer {
ev.ValueFrom = &api.EnvVarSource{}
ev.ValueFrom.FieldRef = &api.ObjectFieldSelector{}
versions := registered.RegisteredGroupVersions
var versions []unversioned.GroupVersion
for _, testGroup := range testapi.Groups {
versions = append(versions, *testGroup.GroupVersion())
}
ev.ValueFrom.FieldRef.APIVersion = versions[c.Rand.Intn(len(versions))].String()
ev.ValueFrom.FieldRef.FieldPath = c.RandString()

10
pkg/api/v1/register.go
View File

@@ -18,7 +18,6 @@ package v1
import (
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/registered"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/runtime"
)
@@ -32,13 +31,8 @@ var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1
// Codec encodes internal objects to the v1 scheme
var Codec = runtime.CodecFor(api.Scheme, SchemeGroupVersion)
func init() {
// Check if v1 is in the list of supported API versions.
if !registered.IsRegisteredAPIGroupVersion(SchemeGroupVersion) {
return
}
// Register the API.
func AddToScheme() {
// Add the API to Scheme.
addKnownTypes()
addConversionFuncs()
addDefaultingFuncs()