jiebi/CodeConvo huggingface dataset:
Change:
What happened: I noticed a typo when glancing at What you expected to happen: A diff of help would explain it best, I think. (old = current, new = desired) How to reproduce it (as minimally and precisely as possible): Anything else we need to know?: I've got a PR ready. Environment: Kubernetes version (use ): v1.14.1 Cloud provider or hardware configuration: not applicable OS (e.g: ): Ubuntu 18.04 Kernel (e.g. ): not relevant Install tools: not relevant Network plugin and version (if this is a network-related bug): not relevant Others:
/sig docs
/sig cli

Discussion:
renameContextLong = templates.LongDesc(` Renames a context from the kubeconfig file. <del> CONTEXT_NAME is the context name that you wish change. </del> <ins> CONTEXT_NAME is the context name that you wish to change. </ins> NEW_NAME is the new name you wish to set.
Change:
cc ref
There are no sig labels on this issue. Please add a sig label by either: a sig: e.g., to notify the contributor experience sig, OR the label manually: e.g., to apply the label Note: Method 1 will trigger an email to the group. See the . The in method 1 has to be replaced with one of these: bugs, feature-requests, pr-reviews, test-failures, proposals. <detailsInstructions for interacting with me using PR comments are available . If you have questions or suggestions related to my behavior, please file an issue against the repository. </details
- can you please take a look, you introduced this test and it may mean real problem with your code
I took a quick look and this is a test issue. The problem is that the implementation explicitly assumes there is at most one call to dispatchEvent at a given time. And this particular test breaks this assumption: The problem is that, a given iteration is finished when is closed, which may actually happen as a result of even before is called (since it's a different goroutine). And then may be called concurrently with the next iteration, which triggers a race. The fix is simple, we should ensure that all goroutines are finished before starting the next iteration.
/cc

Discussion:
"testing" "time" <del> "k8s.io/api/core/v1" </del> <ins> v1 "k8s.io/api/core/v1" </ins> "k8s.io/apimachinery/pkg/api/meta" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/fields"

t.Fatalf("failure to update version of object (%d) %#v", bookmark.ResourceVersion, bookmark.Object) } <ins> wg := sync.WaitGroup{} wg.Add(2) </ins> go func() { cacher.dispatchEvent(bookmark) <ins> wg.Done() </ins> }() go func() { w.Stop() <ins> wg.Done() </ins> }() done := make(chan struct{})

t.Fatal("receive result timeout") } w.Stop() <ins> wg.Wait() </ins> } }
Change:
<!-- Please only use this template for submitting enhancement requests -- What would you like to be : related to Why is this needed: /assign /sig azure
here is the way about how to get MaxDataDiskCount: and then build kubelet, copy kubelet to agent node and then get MaxDataDiskCount data: There are 207 VM sizes totally.
Update: this command could get VM size list easily:

Discussion:
"STANDARD_D3_V2":         16, "STANDARD_D3_V2_PROMO":   16, "STANDARD_D4":            32, <ins> "STANDARD_D48AS_V4":      32, "STANDARD_D48A_V4":       32, </ins> "STANDARD_D48S_V3":       32, "STANDARD_D48_V3":        32, "STANDARD_D4AS_V4":       8,

"STANDARD_D4_V3":         8, "STANDARD_D5_V2":         64, "STANDARD_D5_V2_PROMO":   64, <ins> "STANDARD_D64AS_V4":      32, "STANDARD_D64A_V4":       32, </ins> "STANDARD_D64S_V3":       32, "STANDARD_D64_V3":        32, "STANDARD_D8AS_V4":       16, "STANDARD_D8A_V4":        16, "STANDARD_D8S_V3":        16, "STANDARD_D8_V3":         16, <ins> "STANDARD_D96AS_V4":      32, "STANDARD_D96A_V4":       32, </ins> "STANDARD_DC1S_V2":       1, "STANDARD_DC2S":          2, "STANDARD_DC2S_V2":       2, "STANDARD_DC4S":          4, "STANDARD_DC4S_V2":       4, <del> "STANDARD_DC8S":          8, </del> "STANDARD_DC8_V2":        8, "STANDARD_DS11-1_V2":     8, "STANDARD_DS11":          8,

"STANDARD_E32_V3":        32, "STANDARD_E4-2S_V3":      8, "STANDARD_E48AS_V4":      32, <ins> "STANDARD_E48A_V4":       32, </ins> "STANDARD_E48S_V3":       32, "STANDARD_E48_V3":        32, "STANDARD_E4AS_V4":       8,

"STANDARD_E64-16S_V3":    32, "STANDARD_E64-32S_V3":    32, "STANDARD_E64AS_V4":      32, <ins> "STANDARD_E64A_V4":       32, </ins> "STANDARD_E64IS_V3":      32, "STANDARD_E64I_V3":       32, "STANDARD_E64S_V3":       32,

"STANDARD_E8S_V3":        16, "STANDARD_E8_V3":         16, "STANDARD_E96AS_V4":      32, <ins> "STANDARD_E96A_V4":       32, </ins> "STANDARD_F1":            4, "STANDARD_F16":           64, "STANDARD_F16S":          64,

"STANDARD_NV12_PROMO":    48, "STANDARD_NV12S_V2":      24, "STANDARD_NV12S_V3":      12, <ins> "STANDARD_NV16AS_V4":     32, </ins> "STANDARD_NV24":          64, "STANDARD_NV24_PROMO":    64, "STANDARD_NV24S_V2":      32, "STANDARD_NV24S_V3":      24, <ins> "STANDARD_NV32AS_V4":     32, </ins> "STANDARD_NV48S_V3":      32, <ins> "STANDARD_NV4AS_V4":      8, </ins> "STANDARD_NV6":           24, "STANDARD_NV6_PROMO":     24, "STANDARD_NV6S_V2":       12, <ins> "STANDARD_NV8AS_V4":      16, </ins> "STANDARD_PB6S":          12, }
Change:
What would you like to be : Deprecate the flag which enables exposing logs of apiserver. Why is this needed: As per , in order to disable accessing apiserver logs in the future, we need to deprecate the current default and wait for the requisite time period.
/sig api-machinery
/assign
I'm in favor of deprecating this. It's potentially disruptive, I think an email blast to kubernetes-dev would be a good idea.
Thanks , I have posted in kubernetes-dev mailing list.
I'm also in favor of removing this functionality from the apiserver. Since this is GA behavior, the deprecation period would be 12 months.
cc

Discussion:
fs.BoolVar(&s.EnableLogsHandler, "enable-logs-handler", s.EnableLogsHandler, "If true, install a /logs handler for the apiserver logs.") <ins> fs.MarkDeprecated("enable-logs-handler", "This flag will be removed in v1.19") </ins> // Deprecated in release 1.9 fs.StringVar(&s.SSHUser, "ssh-user", s.SSHUser,
Change:
Found by failing TestApplyConvertsManagedFieldsVersion test in () It seems that conversion depends on schema info that is collected from served API versions only. However, managedFields stores data in etcd from REST versions served in previous releases which may no longer be served. That means that we have to be able to deal with managedFields persisted via API calls to versions that are no longer served, but which we still have and understand conversions for. /cc /sig api-machinery /wg apply /priority important-soon
This may be fixed in a more recent version of structured-merge-diff. I'll look into it
/assign
At one point we were using the types registered to the scheme to generate the openAPI definitions used by apply, but we switched to using the installed endpoints instead, because it was less invasive (We needed to expose which types are convertible to which other types, and also a way to skip generating openAPI for internal types). We might want to revisit the first approach, given this use case.

Discussion:
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/runtime" <ins> "k8s.io/apimachinery/pkg/runtime/schema" </ins> "k8s.io/kube-openapi/pkg/util/proto" "sigs.k8s.io/structured-merge-diff/typed" "sigs.k8s.io/structured-merge-diff/value"

gvk := obj.GetObjectKind().GroupVersionKind() t := c.parser.Type(gvk) if t == nil { <del> return nil, fmt.Errorf("no corresponding type for %v", gvk) </del> <ins> return nil, newNoCorrespondingTypeError(gvk) </ins> } return t.FromUnstructured(u) }

gvk := unstructured.GetObjectKind().GroupVersionKind() t := c.parser.Type(gvk) if t == nil { <del> return nil, fmt.Errorf("no corresponding type for %v", gvk) </del> <ins> return nil, newNoCorrespondingTypeError(gvk) </ins> } return t.FromYAML(typed.YAMLObject(string(from))) }

} return &unstructured.Unstructured{Object: u}, nil } <ins> type noCorrespondingTypeErr struct { gvk schema.GroupVersionKind } func newNoCorrespondingTypeError(gvk schema.GroupVersionKind) error { return &noCorrespondingTypeErr{gvk: gvk} } func (k *noCorrespondingTypeErr) Error() string { return fmt.Sprintf("no corresponding type for %v", k.gvk) } func isNoCorrespondingTypeError(err error) bool { if err == nil { return false } _, ok := err.(*noCorrespondingTypeErr) return ok } </ins>

// IsMissingVersionError func (v *versionConverter) IsMissingVersionError(err error) bool { <del> return runtime.IsNotRegisteredError(err) </del> <ins> return runtime.IsNotRegisteredError(err) || isNoCorrespondingTypeError(err) </ins> }
Change:
<!-- Please use this template while reporting a bug and provide as much info as possible. Not doing so may result in your bug not being addressed in a timely manner. Thanks! If the matter is security related, please disclose it privately via --What happened: I ran to build latest Kubernetes source code, and then I see the binaries are still stripped: And I can not use dlv to debug the binary: In Makefile, I see the following comments: But that seems not correct in my build. What you expected to happen: I expected Kubernetes binaries with debug info. How to reproduce it (as minimally and precisely as possible): Anything else we need to know?: Environment: Kubernetes version (use ): Latest Kubernetes source code. Cloud provider or hardware configuration: A virtual machine with 2 cores and 8GB RAM. OS (e.g: ): 18.04 LTS (Bionic Beaver) Kernel (e.g. ): Linux workstation 4.15.0-23-generic -Ubuntu SMP Wed May 23 18:02:16 UTC 2018 x8664 x8664 x86_64 GNU/Linux Install tools: Network plugin and version (if this is a network-related bug): Others:
/sig release
It is the problem of "-ldflags -s -w" and I will provide a PR ASAP. /cc
please set to an empty string and see if that helps
Yes, this is my fix solution (Remove '-s -w' from goldflags). Meanwhile, I had verified that it works.
I tried and it works! So I think the comments in the Makefile need to be updated a bit since only is not enough for debugger to debug Kubernetes binaries.
It should work after you explicitly specify GOLDFLAGS="" in command line. If GOLDFLAGS is not specified, the default value is "-w -s". It turns out all binaries are built as stripped.
yes, please update comments in the Makefile to
in my case for kubernetes1.13.5, removing '-s -w' from goldflags is enough.

Discussion:
#   make #   make all #   make all WHAT=cmd/kubelet GOFLAGS=-v <del> #   make all GOGCFLAGS="-N -l" #     Note: Use the -N -l options to disable compiler optimizations an inlining. #           Using these build options allows you to subsequently use source #           debugging tools like delve. </del> <ins> #   make all GOLDFLAGS="" #     Note: Specify GOLDFLAGS as an empty string for building unstripped binaries, which allows #           you to use code debugging tools like delve. When GOLDFLAGS is unspecified, it defaults #           to "-s -w" which strips debug information. Other flags that can be used for GOLDFLAGS #           are documented at https://golang.org/cmd/link/ </ins> endef .PHONY: all ifeq ($(PRINT_HELP),y)
Change:
<!-- Please only use this template for submitting reports about failing tests in Kubernetes CI jobs --Which jobs are failing: sig-scalability-gce/gce-scale-performance Which test(s) are failing: Up Since when has it been failing: since today Testgrid link: https://k8s- Reason for failure: Set-up scripts report only 500 nodes to be up, even though we see in api-server more nodes that registered
/sig scalability /assign
Looks like the pagination (controlled via --chunk-size) was enabled in kubectl. The default is 500 rows, which explains the behavior we see in the failing tests. I wasn't able to find the culprit PR, but found an easy fix. Will send a PR shortly
broke in , fixed in (with tests)
Ah, thanks, I thought could related, but it wasn't really obvious to me that it was the real culprit. Thanks for fixing, once gets merged we can revert
FYI, the temporary workaround seems to be working, the gce-scale-performance is running and not failing anymore on cluster creation -

Discussion:
# which are important for line counting. # Use trick from https://unix.stackexchange.com/a/383411 to avoid # newline truncation. <del> node=$(kubectl_retry get nodes --chunk-size=0 --no-headers; ret=$?; echo .; exit "$ret") && res="$?" || res="$?" </del> <ins> node=$(kubectl_retry get nodes --no-headers; ret=$?; echo .; exit "$ret") && res="$?" || res="$?" </ins> node="${node%.}" if [ "${res}" -ne "0" ]; then if [[ "${attempt}" -gt "${last_run:-$MAX_ATTEMPTS}" ]]; then
Change:
Hello , I have saw the commit , can we check the for enqueue to serivce cotnroller work queue? basecause of, In many case for Public Cloud, We always abstract a set for health checks , such as TargetGroup in AWS, instanceGroup in aliyun. We can map to such a collection of instance. If the service controller to check the targetgroup changes, the traffic pass-through pod is easier to implement. In most cases, the instance that in same group has an associated port for external services, and service controller set a target port if which not set in service yaml file. On the other handWe only lose some other performance of service controller. and Implementing targetgroup mapping to targetport depends on the cloud provider. What do you think? /sig cloud-provider /sig network
/triage unresolved Comment when the issue is assessed and confirmed. I am a bot run by vllry. ‍

Discussion:
"//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/types:go_default_library", <ins> "//staging/src/k8s.io/apimachinery/pkg/util/intstr:go_default_library", </ins> "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library", "//staging/src/k8s.io/client-go/informers:go_default_library", "//staging/src/k8s.io/client-go/kubernetes/fake:go_default_library",

return false } <del> // We don't check TargetPort; that is not relevant for load balancing // TODO: Should we blank it out?  Or just check it anyway? </del> <ins> if x.TargetPort != y.TargetPort { return false } </ins> return true }

"testing" "time" <del> v1 "k8s.io/api/core/v1" </del> <ins> "k8s.io/api/core/v1" </ins> apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/types" <ins> "k8s.io/apimachinery/pkg/util/intstr" </ins> utilfeature "k8s.io/apiserver/pkg/util/feature" "k8s.io/client-go/informers" "k8s.io/client-go/kubernetes/fake"

}, expectedNeedsUpdate: true, }, <ins> { testName: "If TargetGroup is different 1", updateFn: func() { oldSvc = &v1.Service{ ObjectMeta: metav1.ObjectMeta{ Name:      "tcp-service", Namespace: "default", }, Spec: v1.ServiceSpec{ Ports: []v1.ServicePort{{ Port:       80, Protocol:   v1.ProtocolTCP, TargetPort: intstr.Parse("20"), }}, Type: v1.ServiceTypeLoadBalancer, }, } newSvc = oldSvc.DeepCopy() newSvc.Spec.Ports[0].TargetPort = intstr.Parse("21") }, expectedNeedsUpdate: true, }, { testName: "If TargetGroup is different 2", updateFn: func() { oldSvc = &v1.Service{ ObjectMeta: metav1.ObjectMeta{ Name:      "tcp-service", Namespace: "default", }, Spec: v1.ServiceSpec{ Ports: []v1.ServicePort{{ Port:       80, Protocol:   v1.ProtocolTCP, TargetPort: intstr.Parse("22"), }}, Type: v1.ServiceTypeLoadBalancer, }, } newSvc = oldSvc.DeepCopy() newSvc.Spec.Ports[0].TargetPort = intstr.Parse("dns") }, expectedNeedsUpdate: true, }, </ins> } controller, _, _ := newController()
Change:
What happened: Kubelet had crashed one one of the heavily loaded instances in AWS EC2 cluster (r4.8xlarge). Logs show the following traceback: What you expected to happen: Kubelet not to crash. How to reproduce it (as minimally and precisely as possible): Reproduction unknown at this point. Anything else we need to know?: Environment: Kubernetes version (use ): Kubelet v.1.12.7; Control plane v.1.12.8 Cloud provider or hardware configuration: AWS/EC2 OS (e.g: ): CentOS Linux release 7.6.1810 (Core) Kernel (e.g. ): 5.0.4- (non-standard kernel) Install tools: Custom-made
/sig node
/assign
This seems like we don't check if Memory is not on latest stats
Nice debugging :)

Discussion:
cpuStats.UsageCoreNanoSeconds = &cstat.Cpu.Usage.Total } } <del> if info.Spec.HasMemory { </del> <ins> if info.Spec.HasMemory && cstat.Memory != nil { </ins> pageFaults := cstat.Memory.ContainerData.Pgfault majorPageFaults := cstat.Memory.ContainerData.Pgmajfault memoryStats = &statsapi.MemoryStats{
Change:
What happened: When creating an EBS volume, we're currently waiting for the volume be in the correct state before proceeding: However, we're using the interval defined in (e.g., 1 second), which was meant to be used for another reason and might be too soon for this specific case. Also, this might contribute to the API quota being exceeded. CC /sig storage /sig aws
Yeah I think, this should be considered a regression. Many of our AWS clusters run on very thin margin of API quota and this would tip them over the edge.

Discussion:
createTagFactor       = 2.0 createTagSteps        = 9 <del> // encryptedCheck* is configuration of poll for created volume to check // it has not been silently removed by AWS. </del> <ins> // volumeCreate* is configuration of exponential backoff for created volume. </ins> // On a random AWS account (shared among several developers) it took 4s on <del> // average. encryptedCheckInterval = 1 * time.Second encryptedCheckTimeout  = 30 * time.Second </del> <ins> // average, 8s max. volumeCreateInitialDelay  = 5 * time.Second volumeCreateBackoffFactor = 1.2 volumeCreateBackoffSteps  = 10 </ins> // Number of node names that can be added to a filter. The AWS limit is 200 // but we are using a lower limit on purpose

// Unreachable code return err } <del> err = wait.Poll(encryptedCheckInterval, encryptedCheckTimeout, func() (done bool, err error) { </del> <ins> time.Sleep(5 * time.Second) backoff := wait.Backoff{ Duration: volumeCreateInitialDelay, Factor:   volumeCreateBackoffFactor, Steps:    volumeCreateBackoffSteps, } err = wait.ExponentialBackoff(backoff, func() (done bool, err error) { </ins> vol, err := disk.describeVolume() if err != nil { return true, err
Change:
<!-- Please only use this template for submitting reports about failing tests in Kubernetes CI jobs --Which jobs are failing: N/A Which test(s) are failing: should support configurable pod Since when has it been failing: N/A Testgrid link: N/A Reason for failure: Since ` was used instead. Anything else we need to know: /sig testing /sig windows

Discussion:
CROSS_BUILD_COPY qemu-QEMUARCH-static /usr/bin/ RUN apk add --no-cache bind-tools dnsmasq <ins> ADD https://github.com/coredns/coredns/releases/download/v1.5.0/coredns_1.5.0_linux_BASEARCH.tgz /coredns.tgz RUN tar -xzvf /coredns.tgz && rm -f /coredns.tgz </ins>

<ins> # Copyright 2019 The Kubernetes Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # #     http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. FROM BASEIMAGE USER ContainerAdministrator ENV chocolateyUseWindowsCompression false RUN powershell -Command  iex ((new-object net.webclient).DownloadString('https://chocolatey.org/install.ps1'));  choco feature disable --name showDownloadProgress;  powershell -Command choco install bind-toolsonly --version 9.10.3 -y RUN powershell -Command " wget -uri 'https://github.com/coredns/coredns/releases/download/v1.5.0/coredns_1.5.0_windows_amd64.tgz' -OutFile 'C:coredns.tgz'; tar -xzvf 'C:coredns.tgz'; Remove-Item 'C:coredns.tgz'" ADD hostname /bin/hostname.exe </ins>

<del> 1.1 </del> <ins> 1.2 </ins>

RUN apt-get -q update &&  apt-get install -y dnsutils &&  apt-get clean <ins> ADD https://github.com/coredns/coredns/releases/download/v1.5.0/coredns_1.5.0_linux_BASEARCH.tgz /coredns.tgz RUN tar -xzvf /coredns.tgz && rm -f /coredns.tgz </ins>

<del> 1.0 </del> <ins> 1.1 </ins>
Change:
Commits and on master via PRs and have broken MacOS 'make' again: where "MacOS" is a non-homebrew extended MacOS with old old bash. This is also reported on other older platforms like CentOS. Master needs fixed with a new commit, then the above PRs and and the new fix need cherry picked to 1.14 as 1.14.2 is currently not buildable as is cherry picked there. :bash_fire"
/sig release /priority critical-urgent
/cc is looking at this

Discussion:
# to readonly. # The configured vars will only contain platforms allowed by the # KUBE_SUPPORTED* vars at the top of this file. <del> declare -a -g KUBE_SERVER_PLATFORMS declare -a -g KUBE_CLIENT_PLATFORMS declare -a -g KUBE_NODE_PLATFORMS declare -a -g KUBE_TEST_PLATFORMS </del> <ins> declare -a KUBE_SERVER_PLATFORMS declare -a KUBE_CLIENT_PLATFORMS declare -a KUBE_NODE_PLATFORMS declare -a KUBE_TEST_PLATFORMS </ins> kube::golang::setup_platforms() { if [[ -n "${KUBE_BUILD_PLATFORMS:-}" ]]; then # KUBE_BUILD_PLATFORMS needs to be read into an array before the next

KUBE_CLIENT_PLATFORMS=( darwin/amd64 linux/amd64 <del> ) </del> <ins> ) </ins> readonly KUBE_CLIENT_PLATFORMS else KUBE_TEST_PLATFORMS=(linux/amd64)