volcano.sh/volcano@v1.9.0/pkg/webhooks/schema/schema.go (about)

     1  /*
     2  Copyright 2019 The Volcano Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package schema
    18  
    19  import (
    20  	"fmt"
    21  
    22  	admissionv1 "k8s.io/api/admission/v1"
    23  	v1 "k8s.io/api/core/v1"
    24  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    25  	"k8s.io/apimachinery/pkg/runtime"
    26  	"k8s.io/apimachinery/pkg/runtime/serializer"
    27  	"k8s.io/klog/v2"
    28  	corev1 "k8s.io/kubernetes/pkg/apis/core/v1"
    29  
    30  	batchv1alpha1 "volcano.sh/apis/pkg/apis/batch/v1alpha1"
    31  	schedulingv1beta1 "volcano.sh/apis/pkg/apis/scheduling/v1beta1"
    32  )
    33  
    34  func init() {
    35  	addToScheme(scheme)
    36  }
    37  
    38  var scheme = runtime.NewScheme()
    39  
    40  // Codecs is for retrieving serializers for the supported wire formats
    41  // and conversion wrappers to define preferred internal and external versions.
    42  var Codecs = serializer.NewCodecFactory(scheme)
    43  
    44  func addToScheme(scheme *runtime.Scheme) {
    45  	corev1.AddToScheme(scheme)
    46  	admissionv1.AddToScheme(scheme)
    47  }
    48  
    49  // DecodeJob decodes the job using deserializer from the raw object.
    50  func DecodeJob(object runtime.RawExtension, resource metav1.GroupVersionResource) (*batchv1alpha1.Job, error) {
    51  	jobResource := metav1.GroupVersionResource{Group: batchv1alpha1.SchemeGroupVersion.Group, Version: batchv1alpha1.SchemeGroupVersion.Version, Resource: "jobs"}
    52  	raw := object.Raw
    53  	job := batchv1alpha1.Job{}
    54  
    55  	if resource != jobResource {
    56  		err := fmt.Errorf("expect resource to be %s", jobResource)
    57  		return &job, err
    58  	}
    59  
    60  	deserializer := Codecs.UniversalDeserializer()
    61  	if _, _, err := deserializer.Decode(raw, nil, &job); err != nil {
    62  		return &job, err
    63  	}
    64  	klog.V(3).Infof("the job struct is %+v", job)
    65  
    66  	return &job, nil
    67  }
    68  
    69  func DecodePod(object runtime.RawExtension, resource metav1.GroupVersionResource) (*v1.Pod, error) {
    70  	podResource := metav1.GroupVersionResource{Group: "", Version: "v1", Resource: "pods"}
    71  	raw := object.Raw
    72  	pod := v1.Pod{}
    73  
    74  	if resource != podResource {
    75  		err := fmt.Errorf("expect resource to be %s", podResource)
    76  		return &pod, err
    77  	}
    78  
    79  	deserializer := Codecs.UniversalDeserializer()
    80  	if _, _, err := deserializer.Decode(raw, nil, &pod); err != nil {
    81  		return &pod, err
    82  	}
    83  	klog.V(3).Infof("the pod struct is %+v", pod)
    84  
    85  	return &pod, nil
    86  }
    87  
    88  // DecodeQueue decodes the queue using deserializer from the raw object.
    89  func DecodeQueue(object runtime.RawExtension, resource metav1.GroupVersionResource) (*schedulingv1beta1.Queue, error) {
    90  	queueResource := metav1.GroupVersionResource{
    91  		Group:    schedulingv1beta1.SchemeGroupVersion.Group,
    92  		Version:  schedulingv1beta1.SchemeGroupVersion.Version,
    93  		Resource: "queues",
    94  	}
    95  
    96  	if resource != queueResource {
    97  		return nil, fmt.Errorf("expect resource to be %s", queueResource)
    98  	}
    99  
   100  	queue := schedulingv1beta1.Queue{}
   101  	if _, _, err := Codecs.UniversalDeserializer().Decode(object.Raw, nil, &queue); err != nil {
   102  		return nil, err
   103  	}
   104  
   105  	return &queue, nil
   106  }
   107  
   108  // DecodePodGroup decodes the podgroup using deserializer from the raw object.
   109  func DecodePodGroup(object runtime.RawExtension, resource metav1.GroupVersionResource) (*schedulingv1beta1.PodGroup, error) {
   110  	podgroupResource := metav1.GroupVersionResource{
   111  		Group:    schedulingv1beta1.SchemeGroupVersion.Group,
   112  		Version:  schedulingv1beta1.SchemeGroupVersion.Version,
   113  		Resource: "podgroups",
   114  	}
   115  
   116  	if resource != podgroupResource {
   117  		return nil, fmt.Errorf("expect resource to be %s", podgroupResource)
   118  	}
   119  
   120  	podgroup := schedulingv1beta1.PodGroup{}
   121  	if _, _, err := Codecs.UniversalDeserializer().Decode(object.Raw, nil, &podgroup); err != nil {
   122  		return nil, err
   123  	}
   124  
   125  	return &podgroup, nil
   126  }