jiebi/CodeConvo huggingface dataset:
namespace := "default" name := "kubernetes" endpoints, err := cs.CoreV1().Endpoints(namespace).Get(context.TODO(), name, metav1.GetOptions{}) <del> framework.ExpectNoError(err) </del> <ins> framework.ExpectNoError(err, "error creating Endpoints resource") </ins> if len(endpoints.Subsets) != 1 { framework.Failf("Expected 1 subset in endpoints, got %d: %#v", len(endpoints.Subsets), endpoints.Subsets) } endpointSubset := endpoints.Subsets[0] endpointSlice, err := cs.DiscoveryV1beta1().EndpointSlices(namespace).Get(context.TODO(), name, metav1.GetOptions{}) <del> framework.ExpectNoError(err) </del> <ins> framework.ExpectNoError(err, "error creating EndpointSlice resource") </ins> if len(endpointSlice.Ports) != len(endpointSubset.Ports) { framework.Failf("Expected EndpointSlice to have %d ports, got %d: %#v", len(endpointSubset.Ports), len(endpointSlice.Ports), endpointSlice.Ports) }
}) // Expect Endpoints resource to be created. <del> if err := wait.PollImmediate(2*time.Second, 12*time.Second, func() (bool, error) { </del> <ins> if err := wait.PollImmediate(2*time.Second, wait.ForeverTestTimeout, func() (bool, error) { </ins> _, err := cs.CoreV1().Endpoints(svc.Namespace).Get(context.TODO(), svc.Name, metav1.GetOptions{}) if err != nil { return false, nil
// Expect EndpointSlice resource to be created. var endpointSlice discoveryv1beta1.EndpointSlice <del> if err := wait.PollImmediate(2*time.Second, 12*time.Second, func() (bool, error) { </del> <ins> if err := wait.PollImmediate(2*time.Second, wait.ForeverTestTimeout, func() (bool, error) { </ins> endpointSliceList, err := cs.DiscoveryV1beta1().EndpointSlices(svc.Namespace).List(context.TODO(), metav1.ListOptions{ LabelSelector: "kubernetes.io/service-name=" + svc.Name, })
} err := cs.CoreV1().Services(svc.Namespace).Delete(context.TODO(), svc.Name, metav1.DeleteOptions{}) <del> framework.ExpectNoError(err) </del> <ins> framework.ExpectNoError(err, "error deleting Service") </ins> // Expect Endpoints resource to be deleted when Service is. <del> if err := wait.PollImmediate(2*time.Second, 12*time.Second, func() (bool, error) { </del> <ins> if err := wait.PollImmediate(2*time.Second, wait.ForeverTestTimeout, func() (bool, error) { </ins> _, err := cs.CoreV1().Endpoints(svc.Namespace).Get(context.TODO(), svc.Name, metav1.GetOptions{}) if err != nil { if apierrors.IsNotFound(err) {
} // Expect EndpointSlice resource to be deleted when Service is. <del> if err := wait.PollImmediate(2*time.Second, 12*time.Second, func() (bool, error) { </del> <ins> if err := wait.PollImmediate(2*time.Second, wait.ForeverTestTimeout, func() (bool, error) { </ins> endpointSliceList, err := cs.DiscoveryV1beta1().EndpointSlices(svc.Namespace).List(context.TODO(), metav1.ListOptions{ LabelSelector: "kubernetes.io/service-name=" + svc.Name, })
Name: "example-no-match", }, Spec: v1.ServiceSpec{ <del> Selector: map[string]string{labelPod3: labelValue}, </del> <ins> Selector:                 map[string]string{labelPod3: labelValue}, PublishNotReadyAddresses: true, </ins> Ports: []v1.ServicePort{{ Name:       "example-no-match", Port:       80,
}) err := wait.Poll(5*time.Second, 3*time.Minute, func() (bool, error) { <del> if !podClient.PodIsReady(pod1.Name) { framework.Logf("Pod 1 not ready yet") return false, nil } if !podClient.PodIsReady(pod2.Name) { framework.Logf("Pod 2 not ready yet") return false, nil } </del> var err error pod1, err = podClient.Get(context.TODO(), pod1.Name, metav1.GetOptions{}) if err != nil { return false, err } <ins> if len(pod1.Status.PodIPs) == 0 { return false, nil } </ins> pod2, err = podClient.Get(context.TODO(), pod2.Name, metav1.GetOptions{}) if err != nil { return false, err } <ins> if len(pod2.Status.PodIPs) == 0 { return false, nil } </ins> return true, nil }) <del> framework.ExpectNoError(err) </del> <ins> framework.ExpectNoError(err, "timed out waiting for Pods to have IPs assigned") </ins> ginkgo.By("referencing a single matching pod") expectEndpointsAndSlices(cs, f.Namespace.Name, svc1, []*v1.Pod{pod1}, 1, 1, false)
// createServiceReportErr creates a Service and reports any associated error. func createServiceReportErr(cs clientset.Interface, ns string, service *v1.Service) *v1.Service { svc, err := cs.CoreV1().Services(ns).Create(context.TODO(), service, metav1.CreateOptions{}) <del> framework.ExpectNoError(err) </del> <ins> framework.ExpectNoError(err, "error deleting Service") </ins> return svc }
apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/intstr" <ins> "k8s.io/apimachinery/pkg/util/sets" </ins> "k8s.io/apimachinery/pkg/util/wait" clientset "k8s.io/client-go/kubernetes" "k8s.io/kubernetes/test/e2e/framework"
framework.Failf("Expected 1 EndpointSlice, got %d", len(endpointSlices)) } <del> totalEndpointSliceAddresses := 0 </del> <ins> // Use a set for deduping values. Duplicate addresses are technically valid // here although rare. esAddresses := sets.NewString() </ins> for _, endpointSlice := range endpointSlices { <del> totalEndpointSliceAddresses += len(endpointSlice.Endpoints) </del> <ins> for _, endpoint := range endpointSlice.Endpoints { esAddresses.Insert(endpoint.Addresses[0]) } </ins> if len(pods) == 0 && len(endpointSlice.Ports) != 0 { framework.Failf("Expected EndpointSlice to have 0 ports, got %d", len(endpointSlice.Ports)) }
framework.Logf("EndpointSlice for Service %s/%s not found", ns, svcName) return []discoveryv1beta1.EndpointSlice{}, false } <del> if len(esList.Items) != numSlices { framework.Logf("Expected %d EndpointSlices for Service %s/%s, got %d", numSlices, ns, svcName, len(esList.Items)) </del> <ins> // In some cases the EndpointSlice controller will create more // EndpointSlices than necessary resulting in some duplication. This is // valid and tests should only fail here if less EndpointSlices than // expected are added. if len(esList.Items) < numSlices { framework.Logf("Expected at least %d EndpointSlices for Service %s/%s, got %d", numSlices, ns, svcName, len(esList.Items)) </ins> for i, epSlice := range esList.Items { epsData, err := json.Marshal(epSlice) if err != nil {
cs = f.ClientSet }) <del> ginkgo.It("should set default value on new IngressClass", func() { </del> <ins> ginkgo.It("should set default value on new IngressClass [Serial]", func() { </ins> ingressClass1, err := createIngressClass(cs, "ingressclass1", true, f.UniqueName) framework.ExpectNoError(err) defer deleteIngressClass(cs, ingressClass1.Name)
} }) <del> ginkgo.It("should not set default value if no default IngressClass", func() { </del> <ins> ginkgo.It("should not set default value if no default IngressClass [Serial]", func() { </ins> ingressClass1, err := createIngressClass(cs, "ingressclass1", false, f.UniqueName) framework.ExpectNoError(err) defer deleteIngressClass(cs, ingressClass1.Name)
} }) <del> ginkgo.It("should prevent Ingress creation if more than 1 IngressClass marked as default", func() { </del> <ins> ginkgo.It("should prevent Ingress creation if more than 1 IngressClass marked as default [Serial]", func() { </ins> ingressClass1, err := createIngressClass(cs, "ingressclass1", true, f.UniqueName) framework.ExpectNoError(err) defer deleteIngressClass(cs, ingressClass1.Name)
// IngressClass resource create/read/update/watch verbs ginkgo.By("creating") <del> ingressClass1, err := createIngressClass(cs, "ingressclass1", true, f.UniqueName) </del> <ins> ingressClass1, err := createIngressClass(cs, "ingressclass1", false, f.UniqueName) </ins> framework.ExpectNoError(err) <del> _, err = createIngressClass(cs, "ingressclass2", true, f.UniqueName) </del> <ins> _, err = createIngressClass(cs, "ingressclass2", false, f.UniqueName) </ins> framework.ExpectNoError(err) <del> _, err = createIngressClass(cs, "ingressclass3", true, f.UniqueName) </del> <ins> _, err = createIngressClass(cs, "ingressclass3", false, f.UniqueName) </ins> framework.ExpectNoError(err) ginkgo.By("getting")
// SetGroupVersionKind sets or clears the intended serialized kind of an object. Passing kind nil // should clear the current setting. SetGroupVersionKind(kind GroupVersionKind) <del> // GroupVersionKind returns the stored group, version, and kind of an object, or nil if the object does // not expose or provide these fields. </del> <ins> // GroupVersionKind returns the stored group, version, and kind of an object, or an empty struct // if the object does not expose or provide these fields. </ins> GroupVersionKind() GroupVersionKind }
addonmanager.kubernetes.io/mode: Reconcile kubernetes.io/name: "Elasticsearch" spec: <ins> clusterIP: None </ins> ports: <del> - port: 9200 protocol: TCP targetPort: db </del> <ins> - name: db port: 9200 protocol: TCP targetPort: 9200 - name: transport port: 9300 protocol: TCP targetPort: 9300 publishNotReadyAddresses: true </ins> selector: k8s-app: elasticsearch-logging <ins> sessionAffinity: None type: ClusterIP </ins>
k8s-app: elasticsearch-logging addonmanager.kubernetes.io/mode: Reconcile rules: <del> - apiGroups: - "" resources: - "services" - "namespaces" - "endpoints" verbs: - "get" </del> <ins> - apiGroups: - "" - resources: - "services" - "namespaces" - "endpoints" - verbs: - "get" </ins> --- kind: ClusterRoleBinding apiVersion: rbac.authorization.k8s.io/v1
selector: matchLabels: k8s-app: elasticsearch-logging <del> version: v7.4.2 </del> <ins> version: v7.4.2-1 </ins> template: metadata: labels: k8s-app: elasticsearch-logging <del> version: v7.4.2 </del> <ins> version: v7.4.2-1 </ins> spec: serviceAccountName: elasticsearch-logging containers: <del> - image: quay.io/fluentd_elasticsearch/elasticsearch:v7.4.2 name: elasticsearch-logging imagePullPolicy: Always resources: # need more cpu upon initialization, therefore burstable class limits: cpu: 1000m memory: 3Gi requests: cpu: 100m memory: 3Gi ports: - containerPort: 9200 name: db protocol: TCP - containerPort: 9300 name: transport protocol: TCP livenessProbe: tcpSocket: port: transport initialDelaySeconds: 5 timeoutSeconds: 10 readinessProbe: tcpSocket: port: transport initialDelaySeconds: 5 timeoutSeconds: 10 volumeMounts: - name: elasticsearch-logging mountPath: /data env: - name: "NAMESPACE" valueFrom: fieldRef: fieldPath: metadata.namespace </del> <ins> - image: quay.io/fluentd_elasticsearch/elasticsearch:v7.4.2 name: elasticsearch-logging imagePullPolicy: Always resources: # need more cpu upon initialization, therefore burstable class limits: cpu: 1000m memory: 3Gi requests: cpu: 100m memory: 3Gi ports: - containerPort: 9200 name: db protocol: TCP - containerPort: 9300 name: transport protocol: TCP livenessProbe: tcpSocket: port: transport initialDelaySeconds: 5 timeoutSeconds: 10 readinessProbe: tcpSocket: port: transport initialDelaySeconds: 5 timeoutSeconds: 10 volumeMounts: - name: elasticsearch-logging mountPath: /data env: - name: "NAMESPACE" valueFrom: fieldRef: fieldPath: metadata.namespace - name: "MINIMUM_MASTER_NODES" value: "1" </ins> volumes: <del> - name: elasticsearch-logging emptyDir: {} </del> <ins> - name: elasticsearch-logging emptyDir: {} </ins> # Elasticsearch requires vm.max_map_count to be at least 262144. # If your OS already sets up this number to a higher value, feel free # to remove this init container. initContainers: <del> - image: alpine:3.6 command: ["/sbin/sysctl", "-w", "vm.max_map_count=262144"] name: elasticsearch-logging-init securityContext: privileged: true </del> <ins> - image: alpine:3.6 command: ["/sbin/sysctl", "-w", "vm.max_map_count=262144"] name: elasticsearch-logging-init securityContext: privileged: true </ins>
"github.com/onsi/gomega" ) <del> var _ = framework.KubeDescribe("NodeProblemDetector [NodeFeature:NodeProblemDetector]", func() { </del> <ins> var _ = framework.KubeDescribe("NodeProblemDetector [NodeFeature:NodeProblemDetector] [Serial]", func() { </ins> const ( pollInterval   = 1 * time.Second pollConsistent = 5 * time.Second
"//staging/src/k8s.io/apimachinery/pkg/api/resource:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/util/errors:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library", <ins> "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library", </ins> "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library", "//staging/src/k8s.io/kubelet/pkg/apis/deviceplugin/v1beta1:go_default_library", "//staging/src/k8s.io/kubelet/pkg/apis/pluginregistration/v1:go_default_library",
defer m.wg.Done() m.server.Serve(sock) }() <del> _, conn, err := dial(m.socket) if err != nil { return err </del> <ins> var lastDialErr error wait.PollImmediate(1*time.Second, 10*time.Second, func() (bool, error) { var conn *grpc.ClientConn _, conn, lastDialErr = dial(m.socket) if lastDialErr != nil { return false, nil } conn.Close() return true, nil }) if lastDialErr != nil { return lastDialErr </ins> } <del> conn.Close() </del> klog.Infof("Starting to serve on %v", m.socket) return nil
} defer monitoring.CleanupDescriptors(gcmService, projectID) <del> err = monitoring.CreateAdapter(tc.framework.Namespace.ObjectMeta.Name, monitoring.AdapterDefault) </del> <ins> err = monitoring.CreateAdapter(monitoring.AdapterDefault) </ins> if err != nil { framework.Failf("Failed to set up: %v", err) } <del> defer monitoring.CleanupAdapter(tc.framework.Namespace.ObjectMeta.Name, monitoring.AdapterDefault) </del> <ins> defer monitoring.CleanupAdapter(monitoring.AdapterDefault) </ins> // Run application that exports the metric err = createDeploymentToScale(tc.framework, tc.kubeClient, tc.deployment, tc.pod)
// CreateAdapter creates Custom Metrics - Stackdriver adapter // adapterDeploymentFile should be a filename for adapter deployment located in StagingDeploymentLocation <del> func CreateAdapter(namespace, adapterDeploymentFile string) error { </del> <ins> func CreateAdapter(adapterDeploymentFile string) error { </ins> // A workaround to make the work on GKE. GKE doesn't normally allow to create cluster roles, // which the adapter deployment does. The solution is to create cluster role binding for // cluster-admin role and currently used service account. <del> err := createClusterAdminBinding(namespace) </del> <ins> err := createClusterAdminBinding() </ins> if err != nil { return err }
if err != nil { return err } <del> stat, err := framework.RunKubectl(namespace, "create", "-f", adapterURL) </del> <ins> stat, err := framework.RunKubectl("", "create", "-f", adapterURL) </ins> framework.Logf(stat) return err } <del> func createClusterAdminBinding(namespace string) error { </del> <ins> func createClusterAdminBinding() error { </ins> stdout, stderr, err := framework.RunCmd("gcloud", "config", "get-value", "core/account") if err != nil { framework.Logf(stderr)
} serviceAccount := strings.TrimSpace(stdout) framework.Logf("current service account: %q", serviceAccount) <del> stat, err := framework.RunKubectl(namespace, "create", "clusterrolebinding", ClusterAdminBinding, "--clusterrole=cluster-admin", "--user="+serviceAccount) </del> <ins> stat, err := framework.RunKubectl("", "create", "clusterrolebinding", ClusterAdminBinding, "--clusterrole=cluster-admin", "--user="+serviceAccount) </ins> framework.Logf(stat) return err }
} // CleanupAdapter deletes Custom Metrics - Stackdriver adapter deployments. <del> func CleanupAdapter(namespace, adapterDeploymentFile string) { stat, err := framework.RunKubectl(namespace, "delete", "-f", adapterDeploymentFile) </del> <ins> func CleanupAdapter(adapterDeploymentFile string) { stat, err := framework.RunKubectl("", "delete", "-f", adapterDeploymentFile) </ins> framework.Logf(stat) if err != nil { framework.Logf("Failed to delete adapter deployments: %s", err)
if err != nil { framework.Logf("Failed to delete adapter deployment file: %s", err) } <del> cleanupClusterAdminBinding(namespace) </del> <ins> cleanupClusterAdminBinding() </ins> } <del> func cleanupClusterAdminBinding(namespace string) { stat, err := framework.RunKubectl(namespace, "delete", "clusterrolebinding", ClusterAdminBinding) </del> <ins> func cleanupClusterAdminBinding() { stat, err := framework.RunKubectl("", "delete", "clusterrolebinding", ClusterAdminBinding) </ins> framework.Logf(stat) if err != nil { framework.Logf("Failed to delete cluster admin binding: %s", err)
} defer CleanupDescriptors(gcmService, projectID) <del> err = CreateAdapter(f.Namespace.Name, adapterDeployment) </del> <ins> err = CreateAdapter(adapterDeployment) </ins> if err != nil { framework.Failf("Failed to set up: %s", err) } <del> defer CleanupAdapter(f.Namespace.Name, adapterDeployment) </del> <ins> defer CleanupAdapter(adapterDeployment) </ins> _, err = kubeClient.RbacV1().ClusterRoleBindings().Create(context.TODO(), HPAPermissions, metav1.CreateOptions{}) if err != nil {
defer CleanupDescriptors(gcmService, projectID) // Both deployments - for old and new resource model - expose External Metrics API. <del> err = CreateAdapter(f.Namespace.Name, AdapterForOldResourceModel) </del> <ins> err = CreateAdapter(AdapterForOldResourceModel) </ins> if err != nil { framework.Failf("Failed to set up: %s", err) } <del> defer CleanupAdapter(f.Namespace.Name, AdapterForOldResourceModel) </del> <ins> defer CleanupAdapter(AdapterForOldResourceModel) </ins> _, err = kubeClient.RbacV1().ClusterRoleBindings().Create(context.TODO(), HPAPermissions, metav1.CreateOptions{}) if err != nil {
if hosts.Len() > 1 { return } <del> time.Sleep(time.Duration(svcSessionAffinityTimeout) * time.Second) </del> <ins> // In some case, ipvs didn't deleted the persistent connection after timeout expired, // use 'ipvsadm -lnc' command can found the expire time become '13171233:02' after '00:00' // // pro expire state       source             virtual            destination // TCP 00:00  NONE        10.105.253.160:0   10.105.253.160:80  10.244.1.25:9376 // // pro expire state       source             virtual            destination // TCP 13171233:02 NONE        10.105.253.160:0   10.105.253.160:80  10.244.1.25:9376 // // And 2 seconds later, the connection will be ensure deleted, // so we sleep 'svcSessionAffinityTimeout+5' seconds to avoid this issue. // TODO: figure out why the expired connection didn't be deleted and fix this issue in ipvs side. time.Sleep(time.Duration(svcSessionAffinityTimeout+5) * time.Second) </ins> } } framework.Fail("Session is sticky after reaching the timeout")
Filter: &schedulerapi.PluginSet{ Enabled: []schedulerapi.Plugin{ {Name: nodeunschedulable.Name}, <del> {Name: noderesources.FitName}, </del> {Name: nodename.Name}, <del> {Name: nodeports.Name}, </del> <ins> {Name: tainttoleration.Name}, </ins> {Name: nodeaffinity.Name}, <ins> {Name: nodeports.Name}, {Name: noderesources.FitName}, </ins> {Name: volumerestrictions.Name}, <del> {Name: tainttoleration.Name}, </del> {Name: nodevolumelimits.EBSName}, {Name: nodevolumelimits.GCEPDName}, {Name: nodevolumelimits.CSIName},
}, "FilterPlugin": { {Name: "NodeUnschedulable"}, <del> {Name: "NodeResourcesFit"}, </del> {Name: "NodeName"}, <del> {Name: "NodePorts"}, </del> <ins> {Name: "TaintToleration"}, </ins> {Name: "NodeAffinity"}, <ins> {Name: "NodePorts"}, {Name: "NodeResourcesFit"}, </ins> {Name: "VolumeRestrictions"}, <del> {Name: "TaintToleration"}, </del> {Name: "EBSLimits"}, {Name: "GCEPDLimits"}, {Name: "NodeVolumeLimits"},
ErrReasonNodeConflict ConflictReason = "node(s) had volume node affinity conflict" // ErrReasonNotEnoughSpace is used when a pod cannot start on a node because not enough storage space is available. ErrReasonNotEnoughSpace = "node(s) did not have enough free storage" <ins> // ErrReasonPVNotExist is used when a PVC can't find the bound persistent volumes" ErrReasonPVNotExist = "pvc(s) bound to non-existent pv(s)" </ins> ) // BindingInfo holds a binding between PV and PVC.
// Check PV node affinity on bound volumes if len(boundClaims) > 0 { <del> boundVolumesSatisfied, err = b.checkBoundClaims(boundClaims, node, podName) </del> <ins> boundVolumesSatisfied, boundPVsFound, err = b.checkBoundClaims(boundClaims, node, podName) </ins> if err != nil { return }
return boundClaims, unboundClaimsDelayBinding, unboundClaimsImmediate, nil } <del> func (b *volumeBinder) checkBoundClaims(claims []*v1.PersistentVolumeClaim, node *v1.Node, podName string) (bool, error) { </del> <ins> func (b *volumeBinder) checkBoundClaims(claims []*v1.PersistentVolumeClaim, node *v1.Node, podName string) (bool, bool, error) { </ins> csiNode, err := b.csiNodeLister.Get(node.Name) if err != nil { // TODO: return the error once CSINode is created by default
pvName := pvc.Spec.VolumeName pv, err := b.pvCache.GetPV(pvName) if err != nil { <del> return false, err </del> <ins> if _, ok := err.(*errNotFound); ok { err = nil } return true, false, err </ins> } pv, err = b.tryTranslatePVToCSI(pv, csiNode) if err != nil { <del> return false, err </del> <ins> return false, true, err </ins> } err = volumeutil.CheckNodeAffinity(pv, node.Labels) if err != nil { klog.V(4).Infof("PersistentVolume %q, Node %q mismatch for Pod %q: %v", pvName, node.Name, podName, err) <del> return false, nil </del> <ins> return false, true, nil </ins> } klog.V(5).Infof("PersistentVolume %q, Node %q matches for Pod %q", pvName, node.Name, podName) } klog.V(4).Infof("All bound volumes for Pod %q match with Node %q", podName, node.Name) <del> return true, nil </del> <ins> return true, true, nil </ins> } // findMatchingVolumes tries to find matching volumes for given claims,
}, "bound-pvc,pv-not-exists": { podPVCs:    []*v1.PersistentVolumeClaim{boundPVC}, <del> shouldFail: true, </del> <ins> shouldFail: false, reasons:    ConflictReasons{ErrReasonPVNotExist}, </ins> }, "prebound-pvc": { podPVCs:    []*v1.PersistentVolumeClaim{preboundPVC},
}, }, { <ins> name:                "PVC does not exist", pod:                 makePod("pod-a", []string{"pvc-a"}), node:                &v1.Node{}, pvcs:                []*v1.PersistentVolumeClaim{}, wantPreFilterStatus: framework.NewStatus(framework.UnschedulableAndUnresolvable, `persistentvolumeclaim "pvc-a" not found`), }, { name: "Part of PVCs do not exist", pod:  makePod("pod-a", []string{"pvc-a", "pvc-b"}), node: &v1.Node{}, pvcs: []*v1.PersistentVolumeClaim{ makePVC("pvc-a", "pv-a", waitSC.Name), }, wantPreFilterStatus: framework.NewStatus(framework.UnschedulableAndUnresolvable, `persistentvolumeclaim "pvc-b" not found`), }, { </ins> name: "immediate claims not bound", pod:  makePod("pod-a", []string{"pvc-a"}), node: &v1.Node{},
claimsToBind:     []*v1.PersistentVolumeClaim{}, podVolumesByNode: map[string]*scheduling.PodVolumes{}, }, <del> wantFilterStatus: framework.NewStatus(framework.Error, `could not find v1.PersistentVolume "pv-a"`), </del> <ins> wantFilterStatus: framework.NewStatus(framework.UnschedulableAndUnresolvable, `pvc(s) bound to non-existent pv(s)`), </ins> }, }
github.com/gogo/protobuf v1.3.1 github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e github.com/golang/mock v1.4.1 <del> github.com/google/cadvisor v0.38.5 </del> <ins> github.com/google/cadvisor v0.38.6 </ins> github.com/google/go-cmp v0.5.2 github.com/google/gofuzz v1.1.0 github.com/google/uuid v1.1.2
github.com/golangplus/fmt => github.com/golangplus/fmt v0.0.0-20150411045040-2a5d6d7d2995 github.com/golangplus/testing => github.com/golangplus/testing v0.0.0-20180327235837-af21d9c3145e github.com/google/btree => github.com/google/btree v1.0.0 <del> github.com/google/cadvisor => github.com/google/cadvisor v0.38.5 </del> <ins> github.com/google/cadvisor => github.com/google/cadvisor v0.38.6 </ins> github.com/google/go-cmp => github.com/google/go-cmp v0.5.2 github.com/google/gofuzz => github.com/google/gofuzz v1.1.0 github.com/google/martian => github.com/google/martian v2.1.0+incompatible