// readyPods returns the old and new ready counts for their pods. // If a pod is observed as being ready, it's considered ready even // if it later becomes notReady. func (r *RollingUpdater) readyPods(oldRc, newRc *api.ReplicationController, minReadySeconds int32) (int32, int32, error) { controllers := []*api.ReplicationController{oldRc, newRc} oldReady := int32(0) newReady := int32(0) if r.nowFn == nil { r.nowFn = func() metav1.Time { return metav1.Now() } } for i := range controllers { controller := controllers[i] selector := labels.Set(controller.Spec.Selector).AsSelector() options := api.ListOptions{LabelSelector: selector} pods, err := r.podClient.Pods(controller.Namespace).List(options) if err != nil { return 0, 0, err } for _, pod := range pods.Items { v1Pod := &v1.Pod{} if err := v1.Convert_api_Pod_To_v1_Pod(&pod, v1Pod, nil); err != nil { return 0, 0, err } if !deploymentutil.IsPodAvailable(v1Pod, minReadySeconds, r.nowFn().Time) { continue } switch controller.Name { case oldRc.Name: oldReady++ case newRc.Name: newReady++ } } } return oldReady, newReady, nil }
func tryDecodeSinglePod(data []byte, defaultFn defaultFunc) (parsed bool, pod *v1.Pod, err error) { // JSON is valid YAML, so this should work for everything. json, err := utilyaml.ToJSON(data) if err != nil { return false, nil, err } obj, err := runtime.Decode(api.Codecs.UniversalDecoder(), json) if err != nil { return false, pod, err } // Check whether the object could be converted to single pod. if _, ok := obj.(*api.Pod); !ok { err = fmt.Errorf("invalid pod: %#v", obj) return false, pod, err } newPod := obj.(*api.Pod) // Apply default values and validate the pod. if err = defaultFn(newPod); err != nil { return true, pod, err } if errs := validation.ValidatePod(newPod); len(errs) > 0 { err = fmt.Errorf("invalid pod: %v", errs) return true, pod, err } v1Pod := &v1.Pod{} if err := v1.Convert_api_Pod_To_v1_Pod(newPod, v1Pod, nil); err != nil { return true, nil, err } return true, v1Pod, nil }
// GetFirstPod returns a pod matching the namespace and label selector // and the number of all pods that match the label selector. func GetFirstPod(client coreclient.PodsGetter, namespace string, selector labels.Selector, timeout time.Duration, sortBy func([]*v1.Pod) sort.Interface) (*api.Pod, int, error) { options := api.ListOptions{LabelSelector: selector} podList, err := client.Pods(namespace).List(options) if err != nil { return nil, 0, err } pods := []*v1.Pod{} for i := range podList.Items { pod := podList.Items[i] externalPod := &v1.Pod{} v1.Convert_api_Pod_To_v1_Pod(&pod, externalPod, nil) pods = append(pods, externalPod) } if len(pods) > 0 { sort.Sort(sortBy(pods)) internalPod := &api.Pod{} v1.Convert_v1_Pod_To_api_Pod(pods[0], internalPod, nil) return internalPod, len(podList.Items), nil } // Watch until we observe a pod options.ResourceVersion = podList.ResourceVersion w, err := client.Pods(namespace).Watch(options) if err != nil { return nil, 0, err } defer w.Stop() condition := func(event watch.Event) (bool, error) { return event.Type == watch.Added || event.Type == watch.Modified, nil } event, err := watch.Until(timeout, w, condition) if err != nil { return nil, 0, err } pod, ok := event.Object.(*api.Pod) if !ok { return nil, 0, fmt.Errorf("%#v is not a pod event", event) } return pod, 1, nil }
func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) { // add the internal version to Scheme api.AddToScheme(api.Scheme) // 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(api.Scheme) case v1beta3.SchemeGroupVersion: v1beta3.AddToScheme(api.Scheme) } } // This is a "fast-path" that avoids reflection for common types. It focuses on the objects that are // converted the most in the cluster. // TODO: generate one of these for every external API group - this is to prove the impact api.Scheme.AddGenericConversionFunc(func(objA, objB interface{}, s conversion.Scope) (bool, error) { switch a := objA.(type) { case *v1.Pod: switch b := objB.(type) { case *api.Pod: return true, v1.Convert_v1_Pod_To_api_Pod(a, b, s) } case *api.Pod: switch b := objB.(type) { case *v1.Pod: return true, v1.Convert_api_Pod_To_v1_Pod(a, b, s) } case *v1.Event: switch b := objB.(type) { case *api.Event: return true, v1.Convert_v1_Event_To_api_Event(a, b, s) } case *api.Event: switch b := objB.(type) { case *v1.Event: return true, v1.Convert_api_Event_To_v1_Event(a, b, s) } case *v1.ReplicationController: switch b := objB.(type) { case *api.ReplicationController: return true, v1.Convert_v1_ReplicationController_To_api_ReplicationController(a, b, s) } case *api.ReplicationController: switch b := objB.(type) { case *v1.ReplicationController: return true, v1.Convert_api_ReplicationController_To_v1_ReplicationController(a, b, s) } case *v1.Node: switch b := objB.(type) { case *api.Node: return true, v1.Convert_v1_Node_To_api_Node(a, b, s) } case *api.Node: switch b := objB.(type) { case *v1.Node: return true, v1.Convert_api_Node_To_v1_Node(a, b, s) } case *v1.Namespace: switch b := objB.(type) { case *api.Namespace: return true, v1.Convert_v1_Namespace_To_api_Namespace(a, b, s) } case *api.Namespace: switch b := objB.(type) { case *v1.Namespace: return true, v1.Convert_api_Namespace_To_v1_Namespace(a, b, s) } case *v1.Service: switch b := objB.(type) { case *api.Service: return true, v1.Convert_v1_Service_To_api_Service(a, b, s) } case *api.Service: switch b := objB.(type) { case *v1.Service: return true, v1.Convert_api_Service_To_v1_Service(a, b, s) } case *v1.Endpoints: switch b := objB.(type) { case *api.Endpoints: return true, v1.Convert_v1_Endpoints_To_api_Endpoints(a, b, s) } case *api.Endpoints: switch b := objB.(type) { case *v1.Endpoints: return true, v1.Convert_api_Endpoints_To_v1_Endpoints(a, b, s) } } return false, nil }) }