jiebi/CodeConvo huggingface dataset:
Change:
The Jenkins job for GKE upgrade, step 3 (e2e) has been failing since the 4:40pm (PST) run yesterday because of the following DNS problems: This is after the cluster is upgraded.
+cc for triage / suggestions; mentioned as a possibility.
This was almost certainly broken by which was merged at 3:35pm yesterday.
/cc
cc
Yup, my money would be on . Should not be too difficult to track down the bug, given that GCE is working just fine. I'd advise against rolling back if feasible, and rather debug the GKE end of the problem.
Staring at the test it is not clear if anything is wrong with it -- perhaps we need to look at the upgrade code.
I believe that many of the e2e tests begin to fail if DNS isn't working, which to me implies that this is a problem with the test since the failures are isolated to just these two tests. As a side note, I think that this failure is actually correct in the sense that it is catching a legitimate behavioral change between the latest release (0.20.2) and head -- if someone was running code that depended upon the DNS pods to be running in the default namespace and we moved them away then their code would break. In this case, the break was intentional, but it's a behavioral change none the less.
also reported the test failure after upgrade test due to no node is ready in test cluster. We checked it, and found cbr0 is not configured because master never allocate ip range to node, and docker refuse to start.
The code at head selects DNS pods from the system namespace. The code from the 0.20.2 release selects DNS pods from the default namespace. Right now this test is running the e2e test code from the latest release against a cluster that has been upgraded to HEAD.
Thanks for the debugging, all—as Robby said, this catches a behavioral change, which is good. To have the tests pass, we'll want to run the updated tests after an upgrade (this is my next task). I'll mark this as release-note and close it.

Discussion:
printenv | sort echo "--------------------------------------------------------------------------------" <del> if [[ "${E2E_UP,,}" == "true" ]]; then </del> <ins> # We get the Kubernetes tarballs on either cluster creation or when we want to # replace existing ones in a multi-step job (e.g. a cluster upgrade). if [[ "${E2E_UP,,}" == "true" || "${JENKINS_FORCE_GET_TARS:-}" =~ ^[yY]$ ]]; then </ins> if [[ ${KUBE_RUN_FROM_OUTPUT:-} =~ ^[yY]$ ]]; then echo "Found KUBE_RUN_FROM_OUTPUT=y; will use binaries from _output" cp _output/release-tars/kubernetes*.tar.gz . else echo "Pulling binaries from GCS" <del> if [[ $(find . | wc -l) != 1 ]]; then </del> <ins> # In a multi-step job, clean up just the kubernetes build files. # Otherwise, we want a completely empty directory. if [[ "${JENKINS_FORCE_GET_TARS:-}" =~ ^[yY]$ ]]; then rm -rf kubernetes* elif [[ $(find . | wc -l) != 1 ]]; then </ins> echo $PWD not empty, bailing! exit 1 fi
Change:
It works when I pipe but not with filename.
broke in this commit cc
Did you try to add an extension .json to the file? We filter for file extensions
ahhh ok. so working as intended. it used to autodetect :( ... thanks
That was unintended. The file extensions should only be used for deciding which files in a directory to process. For a single file, any extension should be allowed. We don't actually infer the content type from the extensions. For stdin and http sources, for instance, there are no extensions. cc
Fix is pretty straightforward (ignore file extensions when dealing with single file); I have it working with manual test, just adding unit test. Will send shortly.
Thanks, but this is v1.0-post, so no rush

Discussion:
<ins> # Copy of pod.yaml without file extension for test apiVersion: v1 kind: Pod metadata: name: nginx labels: name: nginx spec: containers: - name: nginx image: nginx ports: - containerPort: 80 </ins>

func TestPathBuilderWithMultiple(t *testing.T) { b := NewBuilder(latest.RESTMapper, api.Scheme, fakeClient()). FilenameParam(false, "../../../examples/guestbook/redis-master-controller.yaml"). <del> FilenameParam(false, "../../../examples/guestbook/redis-master-controller.yaml"). </del> <ins> FilenameParam(false, "../../../examples/pod"). </ins> NamespaceParam("test").DefaultNamespace() test := &testVisitor{}

t.Fatalf("unexpected response: %v %t %#v", err, singular, test.Infos) } <del> info := test.Infos[1] if info.Name != "redis-master" || info.Namespace != "test" || info.Object == nil { </del> <ins> info := test.Infos[0] if _, ok := info.Object.(*api.ReplicationController); !ok || info.Name != "redis-master" || info.Namespace != "test" { t.Errorf("unexpected info: %#v", info) } info = test.Infos[1] if _, ok := info.Object.(*api.Pod); !ok || info.Name != "nginx" || info.Namespace != "test" { </ins> t.Errorf("unexpected info: %#v", info) } }

} } <ins> func TestSingularObjectNoExtension(t *testing.T) { obj, err := NewBuilder(latest.RESTMapper, api.Scheme, fakeClient()). NamespaceParam("test").DefaultNamespace(). FilenameParam(false, "../../../examples/pod"). Flatten(). Do().Object() if err != nil { t.Fatalf("unexpected error: %v", err) } pod, ok := obj.(*api.Pod) if !ok { t.Fatalf("unexpected object: %#v", obj) } if pod.Name != "nginx" || pod.Namespace != "test" { t.Errorf("unexpected pod: %#v", pod) } } </ins> func TestSingularRootScopedObject(t *testing.T) { node := &api.Node{ObjectMeta: api.ObjectMeta{Name: "test"}, Spec: api.NodeSpec{ExternalID: "test"}} r := streamTestObject(node)

} return nil } <del> if ignoreFile(path, extensions) { </del> <ins> // Don't check extension if the filepath was passed explicitly if path != paths && ignoreFile(path, extensions) { </ins> return nil }
Change:
Currently, when we change a service with a LoadBalancer, we will often delete the load balancer and create a new one. If possible, we should not do that: on GCE it may involve temporary service disruption, although the new LB has the same IP. On AWS a new ELB is created with a different DNS name, so the user must update their DNS settings. (We have a PR that fixes this , but it is post-v1; I am filing this bug to document the improvement needed, and then changing the tests to test the current state of the world)
How is the LB preserved? indicates it is NOT preserved, making this higher prio.
We do have an e2e test for this, but perhaps it isn't testing what I think it is. highlights that we definitely don't preserve it on AWS, but the test should be checking that it is preserved on GCE.

Discussion:
Failf("got unexpected len(Status.LoadBalancer.Ingresss) for NodePort service: %v", service) } ingress2 := service.Status.LoadBalancer.Ingress[0] <del> // TODO: This is a problem on AWS; we can't just always be changing the LB Expect(ingress1).To(Equal(ingress2)) </del> <ins> // TODO: Fix the issue here: https://github.com/GoogleCloudPlatform/kubernetes/issues/11002 if providerIs("aws") { // TODO: Make this less of a hack (or fix the underlying bug) time.Sleep(time.Second * 120) service, err = waitForLoadBalancerIngress(c, serviceName, ns) Expect(err).NotTo(HaveOccurred()) // We don't want the ingress point to change, but we should verify that the new ingress point still works ingress2 = service.Status.LoadBalancer.Ingress[0] Expect(ingress1).NotTo(Equal(ingress2)) } else { Expect(ingress1).To(Equal(ingress2)) } </ins> By("hitting the pod through the service's updated NodePort") testReachable(ip, nodePort2)
Change:
This was broken by , and therefore broken in as well. Any fix should be offered as a cherry pick so "make release" is clean there.
I went ahead and worked something up for this this morning, to get Shippable builds back on the rails.

Discussion:
"github.com/GoogleCloudPlatform/kubernetes/pkg/api" "github.com/GoogleCloudPlatform/kubernetes/pkg/client" "github.com/GoogleCloudPlatform/kubernetes/pkg/runtime" <ins> "github.com/GoogleCloudPlatform/kubernetes/pkg/util" </ins> ) func TestRunExposeService(t *testing.T) {

Spec: api.ServiceSpec{ Ports: []api.ServicePort{ { <del> Name:     "default", Protocol: api.Protocol("UDP"), Port:     14, </del> <ins> Name:       "default", Protocol:   api.Protocol("UDP"), Port:       14, TargetPort: util.NewIntOrStringFromInt(14), </ins> }, }, Selector: map[string]string{"func": "stream"}, Type:     api.ServiceTypeLoadBalancer, }, }, <del> expected: "you will also need to explicitly open a firewall", status:   200, </del> <ins> status: 200, </ins> }, }
Change:
When you run the "Cluster / " error below line 182: getinstanceprivate_ip: command not found i add the function in cluster/aws/util.s
, André Ribeiro de Miranda < :
any chance you can send a PR? Thanks! --brendan
Actually, let me send a PR. This should just be reversing a delete I made (in error).
if you do want to put together a PR we can of course use that instead, but I deleted this by mistake so I have created a PR to fix my mistake.
Believe also need to change the function check-minion. To make a "ssh forward" by the master. More has the following comment which makes check-minion in the file " 54" I would make this change the "ssh foward" did not do more because of that comment above Thanks
When I am running: export KUBERNETESPROVIDER=aws; wget -q -O - | bash with ENABLENODEPUBLICIP all works fine and the cluster is up, though when running with KUBEENABLENODEPUBLICIP = 0, the cluster won't go up. why the public ip's are needed for the nodes? isn't the VPC good enough? Thanks.

Discussion:
--query Reservations[].Instances[].NetworkInterfaces[0].Association.PublicIp } <ins> function get_instance_private_ip { local instance_id=$1 $AWS_CMD --output text describe-instances  --instance-ids ${instance_id}  --query Reservations[].Instances[].NetworkInterfaces[0].PrivateIpAddress } </ins> # Gets a security group id, by name ($1) function get_security_group_id { local name=$1
Change:
The '-context' does not seem to add any value
add priority and team please.
Blocked on
/sig cli

Discussion:
package config import ( <ins> "fmt" </ins> "io" "path" "strconv"

return boolValue, nil } <ins> func helpErrorf(cmd *cobra.Command, format string, args ...interface{}) error { cmd.Help() msg := fmt.Sprintf(format, args...) return fmt.Errorf("%sn", msg) } </ins>

func (o *createClusterOptions) complete(cmd *cobra.Command) error { args := cmd.Flags().Args() if len(args) != 1 { <del> cmd.Help() return fmt.Errorf("Unexpected args: %v", args) </del> <ins> return helpErrorf(cmd, "Unexpected args: %v", args) </ins> } o.name = args[0]

func (o *createContextOptions) complete(cmd *cobra.Command) error { args := cmd.Flags().Args() if len(args) != 1 { <del> cmd.Help() return fmt.Errorf("Unexpected args: %v", args) </del> <ins> return helpErrorf(cmd, "Unexpected args: %v", args) </ins> } o.name = args[0]

// Complete assigns RenameContextOptions from the args. func (o *RenameContextOptions) Complete(cmd *cobra.Command, args []string, out io.Writer) error { if len(args) != 2 { <del> cmd.Help() return fmt.Errorf("Unexpected args: %v", args) </del> <ins> return helpErrorf(cmd, "Unexpected args: %v", args) </ins> } o.contextName = args[0]

func (o *setOptions) complete(cmd *cobra.Command) error { endingArgs := cmd.Flags().Args() if len(endingArgs) != 2 { <del> cmd.Help() return fmt.Errorf("Unexpected args: %v", endingArgs) </del> <ins> return helpErrorf(cmd, "Unexpected args: %v", endingArgs) </ins> } o.propertyValue = endingArgs[1]

return err } <del> if err := clientcmd.ModifyConfig(o.configAccess, *config, false); err != nil { return err } return nil </del> <ins> return clientcmd.ModifyConfig(o.configAccess, *config, false) </ins> } func (o *unsetOptions) complete(cmd *cobra.Command) error { endingArgs := cmd.Flags().Args() if len(endingArgs) != 1 { <del> cmd.Help() return fmt.Errorf("Unexpected args: %v", endingArgs) </del> <ins> return helpErrorf(cmd, "Unexpected args: %v", endingArgs) </ins> } o.propertyName = endingArgs[0]

cmd := &cobra.Command{ Use:     "use-context CONTEXT_NAME", Short:   i18n.T("Sets the current-context in a kubeconfig file"), <ins> Aliases: []string{"use"}, </ins> Long:    `Sets the current-context in a kubeconfig file`, Example: use_context_example, Run: func(cmd *cobra.Command, args []string) {

config.CurrentContext = o.contextName <del> if err := clientcmd.ModifyConfig(o.configAccess, *config, true); err != nil { return err } return nil </del> <ins> return clientcmd.ModifyConfig(o.configAccess, *config, true) </ins> } func (o *useContextOptions) complete(cmd *cobra.Command) error { endingArgs := cmd.Flags().Args() if len(endingArgs) != 1 { <del> cmd.Help() return fmt.Errorf("Unexpected args: %v", endingArgs) </del> <ins> return helpErrorf(cmd, "Unexpected args: %v", endingArgs) </ins> } o.contextName = endingArgs[0]
Change:
At least on AWS, if the clock drifts 300 seconds (which it will), then we get the rather cryptic message: This is because AWS includes the timestamp in the request. Installing ntpd would stop this drifting from happening. If the drift does happen, the likely symptom is that EC2 calls would stop working: attach/detach volumes on the minions, instance sync and routing configuration on the master. I don't believe that GCE has the same problem.

Discussion:
<ins> ntp: pkg: - installed ntp-service: service: - running - name: ntp - watch: - pkg: ntp </ins>

- base - debian-auto-upgrades - salt-helpers <ins> {% if grains.get('cloud') == 'aws' %} - ntp {% endif %} </ins> 'roles:kubernetes-pool': - match: grain
Change:
The same logs for controller and scheduler. According to , it should be a bug. Some insist it might do no harm though. (all containerized) platform: ubuntu 14.04 docker:1.7.1 /cc
You are not experiencing , your watches are lasting many minutes. would you like to downgrade these messages to warnings so we'll stop getting these reports?
Sure.
If that's the case, i shall wait for the updates. And many thanks.

Discussion:
} if err := r.watchHandler(w, &resourceVersion, resyncCh, stopCh); err != nil { if err != errorResyncRequested && err != errorStopRequested { <del> util.HandleError(fmt.Errorf("%s: watch of %v ended with: %v", r.name, r.expectedType, err)) </del> <ins> glog.Warningf("%s: watch of %v ended with: %v", r.name, r.expectedType, err) </ins> } return }
Change:
When using probe, define the port by number, it works. But if the port is defined by name like below, it doesn't work. it seems should return other than .

Discussion:
func findPortByName(container api.Container, portName string) (int, error) { for _, port := range container.Ports { if port.Name == portName { <del> return port.HostPort, nil </del> <ins> return port.ContainerPort, nil </ins> } } return 0, fmt.Errorf("port %s not found", portName)

container := api.Container{ Ports: []api.ContainerPort{ { <del> Name:     "foo", HostPort: 8080, </del> <ins> Name:          "foo", ContainerPort: 8080, </ins> }, { <del> Name:     "bar", HostPort: 9000, </del> <ins> Name:          "bar", ContainerPort: 9000, </ins> }, }, }

for _, test := range testCases { state := api.PodStatus{PodIP: "127.0.0.1"} container := api.Container{ <del> Ports: []api.ContainerPort{{Name: "found", HostPort: 93}}, </del> <ins> Ports: []api.ContainerPort{{Name: "found", ContainerPort: 93}}, </ins> LivenessProbe: &api.Probe{ Handler: api.Handler{ HTTPGet: test.probe,

for _, test := range testCases { host := "1.2.3.4" container := api.Container{ <del> Ports: []api.ContainerPort{{Name: "found", HostPort: 93}}, </del> <ins> Ports: []api.ContainerPort{{Name: "found", ContainerPort: 93}}, </ins> LivenessProbe: &api.Probe{ Handler: api.Handler{ TCPSocket: test.probe,
Change:
If you spec a /8 for your service Cluster IPs, the bitmask becomes 2 MB, which is too big for etcd. We should enforce that the prefix be /12 or smaller or something like that.
Yes

Discussion:
if s.ServiceClusterIPRange.IP == nil { glog.Fatal("No --service-cluster-ip-range specified") } <ins> var ones, bits = s.ServiceClusterIPRange.Mask.Size() if bits-ones > 20 { glog.Fatal("Specified --service-cluster-ip-range is too large") } </ins> } func newEtcd(etcdConfigFile string, etcdServerList []string, interfacesFunc meta.VersionInterfacesFunc, defaultVersion, storageVersion, pathPrefix string) (etcdStorage storage.Interface, err error) {
Change:
On AWS with Vivid, auplink is not installed. There are messages in the docker log about auplink not being in the path. Inspection of the format-disks script confirms this to be the case. (PR coming soon, just opening an issue so we have something to track it back to!)

Discussion:
if [[ ${#block_devices[@]} == 0 ]]; then echo "No ephemeral block devices found; will use aufs on root" docker_storage="aufs" <del> # Install aufs kernel module (for ubuntu) apt-get install --yes linux-image-extra-$(uname -r) # Install aufs tools (for debian) apt-get install --yes aufs-tools </del> else echo "Block devices: ${block_devices[@]}"

# Install aufs kernel module apt-get install --yes linux-image-extra-$(uname -r) <ins> # Install aufs tools apt-get install --yes aufs-tools </ins> DOCKER_OPTS="${DOCKER_OPTS} -s aufs" elif [[ ${docker_storage} == "devicemapper" ]]; then DOCKER_OPTS="${DOCKER_OPTS} -s devicemapper"
Change:
After was merged, json path test became flaky: in recursive name, expect to get "127.0.0.1 127.0.0.2 myself e2e", got "myself e2e 127.0.0.1 127.0.0.2" FAIL FAIL 0.049s It fails in about 20% of runs.
The problem is with the following case: {"recursive name", "{..name}", nodesData, }, It seems that operator ".." does not guarantee the order in which values are returned. Sometimes they are returned as "127.0.0.1 127.0.0.2 myself e2e", and sometimes as "myself e2e 127.0.0.1 127.0.0.2".
could you please take a look? cc
I've commented-out the offending test-case. We still need the proper fix.
Sorry, I think happens because map iteration order is random . I will fix it as soon as possible.
This was fixed by , closing.

Discussion:
`127.0.0.1 127.0.0.2 127.0.0.3`}, {"double range", "{range .items[*]}{range .status.addresses[*]}{.address}, {end}{end}", nodesData, `127.0.0.1, 127.0.0.2, 127.0.0.3, `}, <del> {"recursive name", "{..name}", nodesData, `127.0.0.1 127.0.0.2 myself e2e`}, </del> <ins> // TODO: fix & uncomment the case bellow (#13024) // {"recursive name", "{..name}", nodesData, `127.0.0.1 127.0.0.2 myself e2e`}, </ins> {"item name", "{.items[*].metadata.name}", nodesData, `127.0.0.1 127.0.0.2`}, {"union nodes capacity", "{.items[*]['metadata.name', 'status.capacity']}", nodesData, `127.0.0.1 127.0.0.2 map[cpu:4] map[cpu:8]`},
Change:
When running the Vagrant Cluster Provider with the following deprecated message is displayed (with some context): Proposed Fix: Simple, change -t to --template in at line 240.
Closing issue as fix was merged.

Discussion:
local count="0" until [[ "$count" == "1" ]]; do local minions <del> minions=$("${KUBE_ROOT}/cluster/kubectl.sh" get nodes -o template -t '{{range.items}}{{.metadata.name}}:{{end}}' --api-version=v1) </del> <ins> minions=$("${KUBE_ROOT}/cluster/kubectl.sh" get nodes -o template --template '{{range.items}}{{.metadata.name}}:{{end}}' --api-version=v1) </ins> count=$(echo $minions | grep -c "${MINION_IPS[i]}") || { printf "." sleep 2
Change:
Greetings, currently, when doing then in column, the ui result is maybe can do something like this instead? remove then join it with
How about something like ?
Greetings, thanks for the interest, I thought I may throw hacking on it. btw, how about for ?
For we can just print since it's master's component.
Hi looks like there is the same issue reported on the OpenShift Origin github: It would make more sense to solve that upstream. Should we do something together to solve it?
There is a pull request for that:

Discussion:
translateTimestamp(e.FirstTimestamp), translateTimestamp(e.LastTimestamp), e.Count, <del> e.Source, </del> <ins> formatEventSource(e.Source), </ins> e.InvolvedObject.FieldPath, e.Type, e.Reason,

event.InvolvedObject.FieldPath, event.Type, event.Reason, <del> event.Source, </del> <ins> formatEventSource(event.Source), </ins> event.Message, ); err != nil { return err

func (p *JSONPathPrinter) HandledResources() []string { return []string{} } <ins> // formatEventSource formats EventSource as a comma separated string excluding Host when empty func formatEventSource(es api.EventSource) string { EventSourceString := []string{es.Component} if len(es.Host) > 0 { EventSourceString = append(EventSourceString, es.Host) } return strings.Join(EventSourceString, ", ") } </ins>
Change:
When a resource violates the limitrange, both for cpu and memory, only one error will be returned at a time. That means when a user is creating such a resource, first it will fail and return something like , them user may edit the cpu usage and create again, then fail again and get . It seem admission controls want to reject the request as fast as possible, if error occurs. But in this case, it may give users a bad experience. Would it be better to aggregate all errors and return them at one time. Also, the error message may cause misunderstanding. , it means the resource requested is 3, it may also cause a confusion that it is limited to 3.
Closing since it's fixed

Discussion:
"k8s.io/kubernetes/pkg/fields" "k8s.io/kubernetes/pkg/labels" "k8s.io/kubernetes/pkg/runtime" <ins> "k8s.io/kubernetes/pkg/util/errors" </ins> "k8s.io/kubernetes/pkg/watch" )

// the specified LimitRange.  The pod may be modified to apply default resource // requirements if not specified, and enumerated on the LimitRange func PodLimitFunc(limitRange *api.LimitRange, pod *api.Pod) error { <ins> var errs []error </ins> defaultResources := defaultContainerResourceRequirements(limitRange) mergePodResourceRequirements(pod, &defaultResources) for i := range limitRange.Spec.Limits { limit := limitRange.Spec.Limits[i] limitType := limit.Type // enforce container limits if limitType == api.LimitTypeContainer { for j := range pod.Spec.Containers { container := &pod.Spec.Containers[j] for k, v := range limit.Min { if err := minConstraint(limitType, k, v, container.Resources.Requests, container.Resources.Limits); err != nil { <del> return err </del> <ins> errs = append(errs, err) </ins> } } for k, v := range limit.Max { if err := maxConstraint(limitType, k, v, container.Resources.Requests, container.Resources.Limits); err != nil { <del> return err </del> <ins> errs = append(errs, err) </ins> } } for k, v := range limit.MaxLimitRequestRatio { if err := limitRequestRatioConstraint(limitType, k, v, container.Resources.Requests, container.Resources.Limits); err != nil { <del> return err </del> <ins> errs = append(errs, err) </ins> } } }

podLimits := sum(containerLimits) for k, v := range limit.Min { if err := minConstraint(limitType, k, v, podRequests, podLimits); err != nil { <del> return err </del> <ins> errs = append(errs, err) </ins> } } for k, v := range limit.Max { if err := maxConstraint(limitType, k, v, podRequests, podLimits); err != nil { <del> return err </del> <ins> errs = append(errs, err) </ins> } } for k, v := range limit.MaxLimitRequestRatio { if err := limitRequestRatioConstraint(limitType, k, v, podRequests, podLimits); err != nil { <del> return err </del> <ins> errs = append(errs, err) </ins> } } } } <del> return nil </del> <ins> return errors.NewAggregate(errs) </ins> }
Change:
The prefix should probably default to the empty string or something like "". When running in the , third party objects are stored to but the double slash is eaten on the HTTP Get:
"registry" would also be a sane default.
Possibly even validate the the specified prefix doesn't end in a slash too.
+1, I encountered this problem last night, too.

Discussion:
// Returns the prefix set via the ETCD_PREFIX environment variable (if any). func PathPrefix() string { <del> return path.Join("/", os.Getenv("ETCD_PREFIX")) </del> <ins> pref := os.Getenv("ETCD_PREFIX") if pref == "" { pref = "registry" } return path.Join("/", pref) </ins> } // Adds the ETCD_PREFIX to the provided key