Switch to github.com/golang/dep for vendoring

Signed-off-by: Mrunal Patel <mrunalp@gmail.com>

vendor/k8s.io/kubernetes/pkg/controller/job/BUILD

@@ -0,0 +1,76 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "jobcontroller.go",
+        "utils.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api/v1:go_default_library",
+        "//pkg/apis/batch/v1:go_default_library",
+        "//pkg/client/cache:go_default_library",
+        "//pkg/client/clientset_generated/clientset:go_default_library",
+        "//pkg/client/clientset_generated/clientset/typed/core/v1:go_default_library",
+        "//pkg/client/listers/batch/v1:go_default_library",
+        "//pkg/client/record:go_default_library",
+        "//pkg/controller:go_default_library",
+        "//pkg/controller/informers:go_default_library",
+        "//pkg/util/metrics:go_default_library",
+        "//pkg/util/workqueue:go_default_library",
+        "//vendor:github.com/golang/glog",
+        "//vendor:k8s.io/apimachinery/pkg/api/errors",
+        "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
+        "//vendor:k8s.io/apimachinery/pkg/util/runtime",
+        "//vendor:k8s.io/apimachinery/pkg/util/wait",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "jobcontroller_test.go",
+        "utils_test.go",
+    ],
+    library = ":go_default_library",
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/v1:go_default_library",
+        "//pkg/apis/batch/v1:go_default_library",
+        "//pkg/client/cache:go_default_library",
+        "//pkg/client/clientset_generated/clientset:go_default_library",
+        "//pkg/client/clientset_generated/clientset/fake:go_default_library",
+        "//pkg/client/restclient:go_default_library",
+        "//pkg/client/testing/core:go_default_library",
+        "//pkg/controller:go_default_library",
+        "//pkg/controller/informers:go_default_library",
+        "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
+        "//vendor:k8s.io/apimachinery/pkg/util/rand",
+        "//vendor:k8s.io/apimachinery/pkg/util/wait",
+        "//vendor:k8s.io/apimachinery/pkg/watch",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/controller/job/OWNERS

@@ -0,0 +1,3 @@
+reviewers:
+- erictune
+- soltysh

vendor/k8s.io/kubernetes/pkg/controller/job/doc.go

@@ -0,0 +1,18 @@
+/*
+Copyright 2015 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.
+*/
+
+// Package job contains logic for watching and synchronizing jobs.
+package job // import "k8s.io/kubernetes/pkg/controller/job"

vendor/k8s.io/kubernetes/pkg/controller/job/jobcontroller.go

@@ -0,0 +1,547 @@
+/*
+Copyright 2015 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.
+*/
+
+package job
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+	"sync"
+	"time"
+
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/kubernetes/pkg/api/v1"
+	batch "k8s.io/kubernetes/pkg/apis/batch/v1"
+	"k8s.io/kubernetes/pkg/client/cache"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/clientset"
+	v1core "k8s.io/kubernetes/pkg/client/clientset_generated/clientset/typed/core/v1"
+	batchv1listers "k8s.io/kubernetes/pkg/client/listers/batch/v1"
+	"k8s.io/kubernetes/pkg/client/record"
+	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/controller/informers"
+	"k8s.io/kubernetes/pkg/util/metrics"
+	"k8s.io/kubernetes/pkg/util/workqueue"
+
+	"github.com/golang/glog"
+)
+
+type JobController struct {
+	kubeClient clientset.Interface
+	podControl controller.PodControlInterface
+
+	// To allow injection of updateJobStatus for testing.
+	updateHandler func(job *batch.Job) error
+	syncHandler   func(jobKey string) error
+	// podStoreSynced returns true if the pod store has been synced at least once.
+	// Added as a member to the struct to allow injection for testing.
+	podStoreSynced cache.InformerSynced
+	// jobStoreSynced returns true if the job store has been synced at least once.
+	// Added as a member to the struct to allow injection for testing.
+	jobStoreSynced cache.InformerSynced
+
+	// A TTLCache of pod creates/deletes each rc expects to see
+	expectations controller.ControllerExpectationsInterface
+
+	// A store of jobs
+	jobLister batchv1listers.JobLister
+
+	// A store of pods, populated by the podController
+	podStore cache.StoreToPodLister
+
+	// Jobs that need to be updated
+	queue workqueue.RateLimitingInterface
+
+	recorder record.EventRecorder
+}
+
+func NewJobController(podInformer cache.SharedIndexInformer, jobInformer informers.JobInformer, kubeClient clientset.Interface) *JobController {
+	eventBroadcaster := record.NewBroadcaster()
+	eventBroadcaster.StartLogging(glog.Infof)
+	// TODO: remove the wrapper when every clients have moved to use the clientset.
+	eventBroadcaster.StartRecordingToSink(&v1core.EventSinkImpl{Interface: kubeClient.Core().Events("")})
+
+	if kubeClient != nil && kubeClient.Core().RESTClient().GetRateLimiter() != nil {
+		metrics.RegisterMetricAndTrackRateLimiterUsage("job_controller", kubeClient.Core().RESTClient().GetRateLimiter())
+	}
+
+	jm := &JobController{
+		kubeClient: kubeClient,
+		podControl: controller.RealPodControl{
+			KubeClient: kubeClient,
+			Recorder:   eventBroadcaster.NewRecorder(v1.EventSource{Component: "job-controller"}),
+		},
+		expectations: controller.NewControllerExpectations(),
+		queue:        workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "job"),
+		recorder:     eventBroadcaster.NewRecorder(v1.EventSource{Component: "job-controller"}),
+	}
+
+	jobInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
+		AddFunc: jm.enqueueController,
+		UpdateFunc: func(old, cur interface{}) {
+			if job := cur.(*batch.Job); !IsJobFinished(job) {
+				jm.enqueueController(job)
+			}
+		},
+		DeleteFunc: jm.enqueueController,
+	})
+	jm.jobLister = jobInformer.Lister()
+	jm.jobStoreSynced = jobInformer.Informer().HasSynced
+
+	podInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
+		AddFunc:    jm.addPod,
+		UpdateFunc: jm.updatePod,
+		DeleteFunc: jm.deletePod,
+	})
+	jm.podStore.Indexer = podInformer.GetIndexer()
+	jm.podStoreSynced = podInformer.HasSynced
+
+	jm.updateHandler = jm.updateJobStatus
+	jm.syncHandler = jm.syncJob
+	return jm
+}
+
+// Run the main goroutine responsible for watching and syncing jobs.
+func (jm *JobController) Run(workers int, stopCh <-chan struct{}) {
+	defer utilruntime.HandleCrash()
+	defer jm.queue.ShutDown()
+
+	if !cache.WaitForCacheSync(stopCh, jm.podStoreSynced, jm.jobStoreSynced) {
+		return
+	}
+
+	for i := 0; i < workers; i++ {
+		go wait.Until(jm.worker, time.Second, stopCh)
+	}
+
+	<-stopCh
+	glog.Infof("Shutting down Job Manager")
+}
+
+// getPodJob returns the job managing the given pod.
+func (jm *JobController) getPodJob(pod *v1.Pod) *batch.Job {
+	jobs, err := jm.jobLister.GetPodJobs(pod)
+	if err != nil {
+		glog.V(4).Infof("No jobs found for pod %v, job controller will avoid syncing", pod.Name)
+		return nil
+	}
+	if len(jobs) > 1 {
+		utilruntime.HandleError(fmt.Errorf("user error! more than one job is selecting pods with labels: %+v", pod.Labels))
+		sort.Sort(byCreationTimestamp(jobs))
+	}
+	return &jobs[0]
+}
+
+// When a pod is created, enqueue the controller that manages it and update it's expectations.
+func (jm *JobController) addPod(obj interface{}) {
+	pod := obj.(*v1.Pod)
+	if pod.DeletionTimestamp != nil {
+		// on a restart of the controller controller, it's possible a new pod shows up in a state that
+		// is already pending deletion. Prevent the pod from being a creation observation.
+		jm.deletePod(pod)
+		return
+	}
+	if job := jm.getPodJob(pod); job != nil {
+		jobKey, err := controller.KeyFunc(job)
+		if err != nil {
+			utilruntime.HandleError(fmt.Errorf("Couldn't get key for job %#v: %v", job, err))
+			return
+		}
+		jm.expectations.CreationObserved(jobKey)
+		jm.enqueueController(job)
+	}
+}
+
+// When a pod is updated, figure out what job/s manage it and wake them up.
+// If the labels of the pod have changed we need to awaken both the old
+// and new job. old and cur must be *v1.Pod types.
+func (jm *JobController) updatePod(old, cur interface{}) {
+	curPod := cur.(*v1.Pod)
+	oldPod := old.(*v1.Pod)
+	if curPod.ResourceVersion == oldPod.ResourceVersion {
+		// Periodic resync will send update events for all known pods.
+		// Two different versions of the same pod will always have different RVs.
+		return
+	}
+	if curPod.DeletionTimestamp != nil {
+		// when a pod is deleted gracefully it's deletion timestamp is first modified to reflect a grace period,
+		// and after such time has passed, the kubelet actually deletes it from the store. We receive an update
+		// for modification of the deletion timestamp and expect an job to create more pods asap, not wait
+		// until the kubelet actually deletes the pod.
+		jm.deletePod(curPod)
+		return
+	}
+	if job := jm.getPodJob(curPod); job != nil {
+		jm.enqueueController(job)
+	}
+	// Only need to get the old job if the labels changed.
+	if !reflect.DeepEqual(curPod.Labels, oldPod.Labels) {
+		// If the old and new job are the same, the first one that syncs
+		// will set expectations preventing any damage from the second.
+		if oldJob := jm.getPodJob(oldPod); oldJob != nil {
+			jm.enqueueController(oldJob)
+		}
+	}
+}
+
+// When a pod is deleted, enqueue the job that manages the pod and update its expectations.
+// obj could be an *v1.Pod, or a DeletionFinalStateUnknown marker item.
+func (jm *JobController) deletePod(obj interface{}) {
+	pod, ok := obj.(*v1.Pod)
+
+	// When a delete is dropped, the relist will notice a pod in the store not
+	// in the list, leading to the insertion of a tombstone object which contains
+	// the deleted key/value. Note that this value might be stale. If the pod
+	// changed labels the new job will not be woken up till the periodic resync.
+	if !ok {
+		tombstone, ok := obj.(cache.DeletedFinalStateUnknown)
+		if !ok {
+			utilruntime.HandleError(fmt.Errorf("Couldn't get object from tombstone %+v", obj))
+			return
+		}
+		pod, ok = tombstone.Obj.(*v1.Pod)
+		if !ok {
+			utilruntime.HandleError(fmt.Errorf("Tombstone contained object that is not a pod %+v", obj))
+			return
+		}
+	}
+	if job := jm.getPodJob(pod); job != nil {
+		jobKey, err := controller.KeyFunc(job)
+		if err != nil {
+			utilruntime.HandleError(fmt.Errorf("Couldn't get key for job %#v: %v", job, err))
+			return
+		}
+		jm.expectations.DeletionObserved(jobKey)
+		jm.enqueueController(job)
+	}
+}
+
+// obj could be an *batch.Job, or a DeletionFinalStateUnknown marker item.
+func (jm *JobController) enqueueController(obj interface{}) {
+	key, err := controller.KeyFunc(obj)
+	if err != nil {
+		utilruntime.HandleError(fmt.Errorf("Couldn't get key for object %+v: %v", obj, err))
+		return
+	}
+
+	// TODO: Handle overlapping controllers better. Either disallow them at admission time or
+	// deterministically avoid syncing controllers that fight over pods. Currently, we only
+	// ensure that the same controller is synced for a given pod. When we periodically relist
+	// all controllers there will still be some replica instability. One way to handle this is
+	// by querying the store for all controllers that this rc overlaps, as well as all
+	// controllers that overlap this rc, and sorting them.
+	jm.queue.Add(key)
+}
+
+// worker runs a worker thread that just dequeues items, processes them, and marks them done.
+// It enforces that the syncHandler is never invoked concurrently with the same key.
+func (jm *JobController) worker() {
+	for jm.processNextWorkItem() {
+	}
+}
+
+func (jm *JobController) processNextWorkItem() bool {
+	key, quit := jm.queue.Get()
+	if quit {
+		return false
+	}
+	defer jm.queue.Done(key)
+
+	err := jm.syncHandler(key.(string))
+	if err == nil {
+		jm.queue.Forget(key)
+		return true
+	}
+
+	utilruntime.HandleError(fmt.Errorf("Error syncing job: %v", err))
+	jm.queue.AddRateLimited(key)
+
+	return true
+}
+
+// syncJob will sync the job with the given key if it has had its expectations fulfilled, meaning
+// it did not expect to see any more of its pods created or deleted. This function is not meant to be invoked
+// concurrently with the same key.
+func (jm *JobController) syncJob(key string) error {
+	startTime := time.Now()
+	defer func() {
+		glog.V(4).Infof("Finished syncing job %q (%v)", key, time.Now().Sub(startTime))
+	}()
+
+	ns, name, err := cache.SplitMetaNamespaceKey(key)
+	if err != nil {
+		return err
+	}
+	if len(ns) == 0 || len(name) == 0 {
+		return fmt.Errorf("invalid job key %q: either namespace or name is missing", key)
+	}
+	sharedJob, err := jm.jobLister.Jobs(ns).Get(name)
+	if err != nil {
+		if errors.IsNotFound(err) {
+			glog.V(4).Infof("Job has been deleted: %v", key)
+			jm.expectations.DeleteExpectations(key)
+			return nil
+		}
+		return err
+	}
+	job := *sharedJob
+
+	// Check the expectations of the job before counting active pods, otherwise a new pod can sneak in
+	// and update the expectations after we've retrieved active pods from the store. If a new pod enters
+	// the store after we've checked the expectation, the job sync is just deferred till the next relist.
+	jobNeedsSync := jm.expectations.SatisfiedExpectations(key)
+	selector, _ := metav1.LabelSelectorAsSelector(job.Spec.Selector)
+	pods, err := jm.podStore.Pods(job.Namespace).List(selector)
+	if err != nil {
+		return err
+	}
+
+	activePods := controller.FilterActivePods(pods)
+	active := int32(len(activePods))
+	succeeded, failed := getStatus(pods)
+	conditions := len(job.Status.Conditions)
+	if job.Status.StartTime == nil {
+		now := metav1.Now()
+		job.Status.StartTime = &now
+	}
+	// if job was finished previously, we don't want to redo the termination
+	if IsJobFinished(&job) {
+		return nil
+	}
+	if pastActiveDeadline(&job) {
+		// TODO: below code should be replaced with pod termination resulting in
+		// pod failures, rather than killing pods. Unfortunately none such solution
+		// exists ATM. There's an open discussion in the topic in
+		// https://github.com/kubernetes/kubernetes/issues/14602 which might give
+		// some sort of solution to above problem.
+		// kill remaining active pods
+		wait := sync.WaitGroup{}
+		wait.Add(int(active))
+		for i := int32(0); i < active; i++ {
+			go func(ix int32) {
+				defer wait.Done()
+				if err := jm.podControl.DeletePod(job.Namespace, activePods[ix].Name, &job); err != nil {
+					defer utilruntime.HandleError(err)
+				}
+			}(i)
+		}
+		wait.Wait()
+		// update status values accordingly
+		failed += active
+		active = 0
+		job.Status.Conditions = append(job.Status.Conditions, newCondition(batch.JobFailed, "DeadlineExceeded", "Job was active longer than specified deadline"))
+		jm.recorder.Event(&job, v1.EventTypeNormal, "DeadlineExceeded", "Job was active longer than specified deadline")
+	} else {
+		if jobNeedsSync && job.DeletionTimestamp == nil {
+			active = jm.manageJob(activePods, succeeded, &job)
+		}
+		completions := succeeded
+		complete := false
+		if job.Spec.Completions == nil {
+			// This type of job is complete when any pod exits with success.
+			// Each pod is capable of
+			// determining whether or not the entire Job is done.  Subsequent pods are
+			// not expected to fail, but if they do, the failure is ignored.  Once any
+			// pod succeeds, the controller waits for remaining pods to finish, and
+			// then the job is complete.
+			if succeeded > 0 && active == 0 {
+				complete = true
+			}
+		} else {
+			// Job specifies a number of completions.  This type of job signals
+			// success by having that number of successes.  Since we do not
+			// start more pods than there are remaining completions, there should
+			// not be any remaining active pods once this count is reached.
+			if completions >= *job.Spec.Completions {
+				complete = true
+				if active > 0 {
+					jm.recorder.Event(&job, v1.EventTypeWarning, "TooManyActivePods", "Too many active pods running after completion count reached")
+				}
+				if completions > *job.Spec.Completions {
+					jm.recorder.Event(&job, v1.EventTypeWarning, "TooManySucceededPods", "Too many succeeded pods running after completion count reached")
+				}
+			}
+		}
+		if complete {
+			job.Status.Conditions = append(job.Status.Conditions, newCondition(batch.JobComplete, "", ""))
+			now := metav1.Now()
+			job.Status.CompletionTime = &now
+		}
+	}
+
+	// no need to update the job if the status hasn't changed since last time
+	if job.Status.Active != active || job.Status.Succeeded != succeeded || job.Status.Failed != failed || len(job.Status.Conditions) != conditions {
+		job.Status.Active = active
+		job.Status.Succeeded = succeeded
+		job.Status.Failed = failed
+
+		if err := jm.updateHandler(&job); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// pastActiveDeadline checks if job has ActiveDeadlineSeconds field set and if it is exceeded.
+func pastActiveDeadline(job *batch.Job) bool {
+	if job.Spec.ActiveDeadlineSeconds == nil || job.Status.StartTime == nil {
+		return false
+	}
+	now := metav1.Now()
+	start := job.Status.StartTime.Time
+	duration := now.Time.Sub(start)
+	allowedDuration := time.Duration(*job.Spec.ActiveDeadlineSeconds) * time.Second
+	return duration >= allowedDuration
+}
+
+func newCondition(conditionType batch.JobConditionType, reason, message string) batch.JobCondition {
+	return batch.JobCondition{
+		Type:               conditionType,
+		Status:             v1.ConditionTrue,
+		LastProbeTime:      metav1.Now(),
+		LastTransitionTime: metav1.Now(),
+		Reason:             reason,
+		Message:            message,
+	}
+}
+
+// getStatus returns no of succeeded and failed pods running a job
+func getStatus(pods []*v1.Pod) (succeeded, failed int32) {
+	succeeded = int32(filterPods(pods, v1.PodSucceeded))
+	failed = int32(filterPods(pods, v1.PodFailed))
+	return
+}
+
+// manageJob is the core method responsible for managing the number of running
+// pods according to what is specified in the job.Spec.
+// Does NOT modify <activePods>.
+func (jm *JobController) manageJob(activePods []*v1.Pod, succeeded int32, job *batch.Job) int32 {
+	var activeLock sync.Mutex
+	active := int32(len(activePods))
+	parallelism := *job.Spec.Parallelism
+	jobKey, err := controller.KeyFunc(job)
+	if err != nil {
+		utilruntime.HandleError(fmt.Errorf("Couldn't get key for job %#v: %v", job, err))
+		return 0
+	}
+
+	if active > parallelism {
+		diff := active - parallelism
+		jm.expectations.ExpectDeletions(jobKey, int(diff))
+		glog.V(4).Infof("Too many pods running job %q, need %d, deleting %d", jobKey, parallelism, diff)
+		// Sort the pods in the order such that not-ready < ready, unscheduled
+		// < scheduled, and pending < running. This ensures that we delete pods
+		// in the earlier stages whenever possible.
+		sort.Sort(controller.ActivePods(activePods))
+
+		active -= diff
+		wait := sync.WaitGroup{}
+		wait.Add(int(diff))
+		for i := int32(0); i < diff; i++ {
+			go func(ix int32) {
+				defer wait.Done()
+				if err := jm.podControl.DeletePod(job.Namespace, activePods[ix].Name, job); err != nil {
+					defer utilruntime.HandleError(err)
+					// Decrement the expected number of deletes because the informer won't observe this deletion
+					jm.expectations.DeletionObserved(jobKey)
+					activeLock.Lock()
+					active++
+					activeLock.Unlock()
+				}
+			}(i)
+		}
+		wait.Wait()
+
+	} else if active < parallelism {
+		wantActive := int32(0)
+		if job.Spec.Completions == nil {
+			// Job does not specify a number of completions.  Therefore, number active
+			// should be equal to parallelism, unless the job has seen at least
+			// once success, in which leave whatever is running, running.
+			if succeeded > 0 {
+				wantActive = active
+			} else {
+				wantActive = parallelism
+			}
+		} else {
+			// Job specifies a specific number of completions.  Therefore, number
+			// active should not ever exceed number of remaining completions.
+			wantActive = *job.Spec.Completions - succeeded
+			if wantActive > parallelism {
+				wantActive = parallelism
+			}
+		}
+		diff := wantActive - active
+		if diff < 0 {
+			utilruntime.HandleError(fmt.Errorf("More active than wanted: job %q, want %d, have %d", jobKey, wantActive, active))
+			diff = 0
+		}
+		jm.expectations.ExpectCreations(jobKey, int(diff))
+		glog.V(4).Infof("Too few pods running job %q, need %d, creating %d", jobKey, wantActive, diff)
+
+		active += diff
+		wait := sync.WaitGroup{}
+		wait.Add(int(diff))
+		for i := int32(0); i < diff; i++ {
+			go func() {
+				defer wait.Done()
+				if err := jm.podControl.CreatePods(job.Namespace, &job.Spec.Template, job); err != nil {
+					defer utilruntime.HandleError(err)
+					// Decrement the expected number of creates because the informer won't observe this pod
+					jm.expectations.CreationObserved(jobKey)
+					activeLock.Lock()
+					active--
+					activeLock.Unlock()
+				}
+			}()
+		}
+		wait.Wait()
+	}
+
+	return active
+}
+
+func (jm *JobController) updateJobStatus(job *batch.Job) error {
+	_, err := jm.kubeClient.Batch().Jobs(job.Namespace).UpdateStatus(job)
+	return err
+}
+
+// filterPods returns pods based on their phase.
+func filterPods(pods []*v1.Pod, phase v1.PodPhase) int {
+	result := 0
+	for i := range pods {
+		if phase == pods[i].Status.Phase {
+			result++
+		}
+	}
+	return result
+}
+
+// byCreationTimestamp sorts a list by creation timestamp, using their names as a tie breaker.
+type byCreationTimestamp []batch.Job
+
+func (o byCreationTimestamp) Len() int      { return len(o) }
+func (o byCreationTimestamp) Swap(i, j int) { o[i], o[j] = o[j], o[i] }
+
+func (o byCreationTimestamp) Less(i, j int) bool {
+	if o[i].CreationTimestamp.Equal(o[j].CreationTimestamp) {
+		return o[i].Name < o[j].Name
+	}
+	return o[i].CreationTimestamp.Before(o[j].CreationTimestamp)
+}

vendor/k8s.io/kubernetes/pkg/controller/job/jobcontroller_test.go

@@ -0,0 +1,724 @@
+/*
+Copyright 2015 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.
+*/
+
+package job
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/rand"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/v1"
+	batch "k8s.io/kubernetes/pkg/apis/batch/v1"
+	"k8s.io/kubernetes/pkg/client/cache"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/clientset"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/clientset/fake"
+	"k8s.io/kubernetes/pkg/client/restclient"
+	"k8s.io/kubernetes/pkg/client/testing/core"
+	"k8s.io/kubernetes/pkg/controller"
+	"k8s.io/kubernetes/pkg/controller/informers"
+)
+
+var alwaysReady = func() bool { return true }
+
+func newJob(parallelism, completions int32) *batch.Job {
+	j := &batch.Job{
+		ObjectMeta: v1.ObjectMeta{
+			Name:      "foobar",
+			Namespace: v1.NamespaceDefault,
+		},
+		Spec: batch.JobSpec{
+			Selector: &metav1.LabelSelector{
+				MatchLabels: map[string]string{"foo": "bar"},
+			},
+			Template: v1.PodTemplateSpec{
+				ObjectMeta: v1.ObjectMeta{
+					Labels: map[string]string{
+						"foo": "bar",
+					},
+				},
+				Spec: v1.PodSpec{
+					Containers: []v1.Container{
+						{Image: "foo/bar"},
+					},
+				},
+			},
+		},
+	}
+	// Special case: -1 for either completions or parallelism means leave nil (negative is not allowed
+	// in practice by validation.
+	if completions >= 0 {
+		j.Spec.Completions = &completions
+	} else {
+		j.Spec.Completions = nil
+	}
+	if parallelism >= 0 {
+		j.Spec.Parallelism = &parallelism
+	} else {
+		j.Spec.Parallelism = nil
+	}
+	return j
+}
+
+func getKey(job *batch.Job, t *testing.T) string {
+	if key, err := controller.KeyFunc(job); err != nil {
+		t.Errorf("Unexpected error getting key for job %v: %v", job.Name, err)
+		return ""
+	} else {
+		return key
+	}
+}
+
+func newJobControllerFromClient(kubeClient clientset.Interface, resyncPeriod controller.ResyncPeriodFunc) (*JobController, informers.SharedInformerFactory) {
+	sharedInformers := informers.NewSharedInformerFactory(kubeClient, nil, resyncPeriod())
+	jm := NewJobController(sharedInformers.Pods().Informer(), sharedInformers.Jobs(), kubeClient)
+
+	return jm, sharedInformers
+}
+
+// create count pods with the given phase for the given job
+func newPodList(count int32, status v1.PodPhase, job *batch.Job) []v1.Pod {
+	pods := []v1.Pod{}
+	for i := int32(0); i < count; i++ {
+		newPod := v1.Pod{
+			ObjectMeta: v1.ObjectMeta{
+				Name:      fmt.Sprintf("pod-%v", rand.String(10)),
+				Labels:    job.Spec.Selector.MatchLabels,
+				Namespace: job.Namespace,
+			},
+			Status: v1.PodStatus{Phase: status},
+		}
+		pods = append(pods, newPod)
+	}
+	return pods
+}
+
+func TestControllerSyncJob(t *testing.T) {
+	testCases := map[string]struct {
+		// job setup
+		parallelism int32
+		completions int32
+		deleting    bool
+
+		// pod setup
+		podControllerError error
+		pendingPods        int32
+		activePods         int32
+		succeededPods      int32
+		failedPods         int32
+
+		// expectations
+		expectedCreations int32
+		expectedDeletions int32
+		expectedActive    int32
+		expectedSucceeded int32
+		expectedFailed    int32
+		expectedComplete  bool
+	}{
+		"job start": {
+			2, 5, false,
+			nil, 0, 0, 0, 0,
+			2, 0, 2, 0, 0, false,
+		},
+		"WQ job start": {
+			2, -1, false,
+			nil, 0, 0, 0, 0,
+			2, 0, 2, 0, 0, false,
+		},
+		"pending pods": {
+			2, 5, false,
+			nil, 2, 0, 0, 0,
+			0, 0, 2, 0, 0, false,
+		},
+		"correct # of pods": {
+			2, 5, false,
+			nil, 0, 2, 0, 0,
+			0, 0, 2, 0, 0, false,
+		},
+		"WQ job: correct # of pods": {
+			2, -1, false,
+			nil, 0, 2, 0, 0,
+			0, 0, 2, 0, 0, false,
+		},
+		"too few active pods": {
+			2, 5, false,
+			nil, 0, 1, 1, 0,
+			1, 0, 2, 1, 0, false,
+		},
+		"too few active pods with a dynamic job": {
+			2, -1, false,
+			nil, 0, 1, 0, 0,
+			1, 0, 2, 0, 0, false,
+		},
+		"too few active pods, with controller error": {
+			2, 5, false,
+			fmt.Errorf("Fake error"), 0, 1, 1, 0,
+			1, 0, 1, 1, 0, false,
+		},
+		"too many active pods": {
+			2, 5, false,
+			nil, 0, 3, 0, 0,
+			0, 1, 2, 0, 0, false,
+		},
+		"too many active pods, with controller error": {
+			2, 5, false,
+			fmt.Errorf("Fake error"), 0, 3, 0, 0,
+			0, 1, 3, 0, 0, false,
+		},
+		"failed pod": {
+			2, 5, false,
+			nil, 0, 1, 1, 1,
+			1, 0, 2, 1, 1, false,
+		},
+		"job finish": {
+			2, 5, false,
+			nil, 0, 0, 5, 0,
+			0, 0, 0, 5, 0, true,
+		},
+		"WQ job finishing": {
+			2, -1, false,
+			nil, 0, 1, 1, 0,
+			0, 0, 1, 1, 0, false,
+		},
+		"WQ job all finished": {
+			2, -1, false,
+			nil, 0, 0, 2, 0,
+			0, 0, 0, 2, 0, true,
+		},
+		"WQ job all finished despite one failure": {
+			2, -1, false,
+			nil, 0, 0, 1, 1,
+			0, 0, 0, 1, 1, true,
+		},
+		"more active pods than completions": {
+			2, 5, false,
+			nil, 0, 10, 0, 0,
+			0, 8, 2, 0, 0, false,
+		},
+		"status change": {
+			2, 5, false,
+			nil, 0, 2, 2, 0,
+			0, 0, 2, 2, 0, false,
+		},
+		"deleting job": {
+			2, 5, true,
+			nil, 1, 1, 1, 0,
+			0, 0, 2, 1, 0, false,
+		},
+	}
+
+	for name, tc := range testCases {
+		// job manager setup
+		clientset := clientset.NewForConfigOrDie(&restclient.Config{Host: "", ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+		manager, sharedInformerFactory := newJobControllerFromClient(clientset, controller.NoResyncPeriodFunc)
+		fakePodControl := controller.FakePodControl{Err: tc.podControllerError}
+		manager.podControl = &fakePodControl
+		manager.podStoreSynced = alwaysReady
+		manager.jobStoreSynced = alwaysReady
+		var actual *batch.Job
+		manager.updateHandler = func(job *batch.Job) error {
+			actual = job
+			return nil
+		}
+
+		// job & pods setup
+		job := newJob(tc.parallelism, tc.completions)
+		if tc.deleting {
+			now := metav1.Now()
+			job.DeletionTimestamp = &now
+		}
+		sharedInformerFactory.Jobs().Informer().GetIndexer().Add(job)
+		podIndexer := sharedInformerFactory.Pods().Informer().GetIndexer()
+		for _, pod := range newPodList(tc.pendingPods, v1.PodPending, job) {
+			podIndexer.Add(&pod)
+		}
+		for _, pod := range newPodList(tc.activePods, v1.PodRunning, job) {
+			podIndexer.Add(&pod)
+		}
+		for _, pod := range newPodList(tc.succeededPods, v1.PodSucceeded, job) {
+			podIndexer.Add(&pod)
+		}
+		for _, pod := range newPodList(tc.failedPods, v1.PodFailed, job) {
+			podIndexer.Add(&pod)
+		}
+
+		// run
+		err := manager.syncJob(getKey(job, t))
+		if err != nil {
+			t.Errorf("%s: unexpected error when syncing jobs %v", name, err)
+		}
+
+		// validate created/deleted pods
+		if int32(len(fakePodControl.Templates)) != tc.expectedCreations {
+			t.Errorf("%s: unexpected number of creates.  Expected %d, saw %d\n", name, tc.expectedCreations, len(fakePodControl.Templates))
+		}
+		if int32(len(fakePodControl.DeletePodName)) != tc.expectedDeletions {
+			t.Errorf("%s: unexpected number of deletes.  Expected %d, saw %d\n", name, tc.expectedDeletions, len(fakePodControl.DeletePodName))
+		}
+		// validate status
+		if actual.Status.Active != tc.expectedActive {
+			t.Errorf("%s: unexpected number of active pods.  Expected %d, saw %d\n", name, tc.expectedActive, actual.Status.Active)
+		}
+		if actual.Status.Succeeded != tc.expectedSucceeded {
+			t.Errorf("%s: unexpected number of succeeded pods.  Expected %d, saw %d\n", name, tc.expectedSucceeded, actual.Status.Succeeded)
+		}
+		if actual.Status.Failed != tc.expectedFailed {
+			t.Errorf("%s: unexpected number of failed pods.  Expected %d, saw %d\n", name, tc.expectedFailed, actual.Status.Failed)
+		}
+		if actual.Status.StartTime == nil {
+			t.Errorf("%s: .status.startTime was not set", name)
+		}
+		// validate conditions
+		if tc.expectedComplete && !getCondition(actual, batch.JobComplete) {
+			t.Errorf("%s: expected completion condition.  Got %#v", name, actual.Status.Conditions)
+		}
+	}
+}
+
+func TestSyncJobPastDeadline(t *testing.T) {
+	testCases := map[string]struct {
+		// job setup
+		parallelism           int32
+		completions           int32
+		activeDeadlineSeconds int64
+		startTime             int64
+
+		// pod setup
+		activePods    int32
+		succeededPods int32
+		failedPods    int32
+
+		// expectations
+		expectedDeletions int32
+		expectedActive    int32
+		expectedSucceeded int32
+		expectedFailed    int32
+	}{
+		"activeDeadlineSeconds less than single pod execution": {
+			1, 1, 10, 15,
+			1, 0, 0,
+			1, 0, 0, 1,
+		},
+		"activeDeadlineSeconds bigger than single pod execution": {
+			1, 2, 10, 15,
+			1, 1, 0,
+			1, 0, 1, 1,
+		},
+		"activeDeadlineSeconds times-out before any pod starts": {
+			1, 1, 10, 10,
+			0, 0, 0,
+			0, 0, 0, 0,
+		},
+	}
+
+	for name, tc := range testCases {
+		// job manager setup
+		clientset := clientset.NewForConfigOrDie(&restclient.Config{Host: "", ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+		manager, sharedInformerFactory := newJobControllerFromClient(clientset, controller.NoResyncPeriodFunc)
+		fakePodControl := controller.FakePodControl{}
+		manager.podControl = &fakePodControl
+		manager.podStoreSynced = alwaysReady
+		manager.jobStoreSynced = alwaysReady
+		var actual *batch.Job
+		manager.updateHandler = func(job *batch.Job) error {
+			actual = job
+			return nil
+		}
+
+		// job & pods setup
+		job := newJob(tc.parallelism, tc.completions)
+		job.Spec.ActiveDeadlineSeconds = &tc.activeDeadlineSeconds
+		start := metav1.Unix(metav1.Now().Time.Unix()-tc.startTime, 0)
+		job.Status.StartTime = &start
+		sharedInformerFactory.Jobs().Informer().GetIndexer().Add(job)
+		podIndexer := sharedInformerFactory.Pods().Informer().GetIndexer()
+		for _, pod := range newPodList(tc.activePods, v1.PodRunning, job) {
+			podIndexer.Add(&pod)
+		}
+		for _, pod := range newPodList(tc.succeededPods, v1.PodSucceeded, job) {
+			podIndexer.Add(&pod)
+		}
+		for _, pod := range newPodList(tc.failedPods, v1.PodFailed, job) {
+			podIndexer.Add(&pod)
+		}
+
+		// run
+		err := manager.syncJob(getKey(job, t))
+		if err != nil {
+			t.Errorf("%s: unexpected error when syncing jobs %v", name, err)
+		}
+
+		// validate created/deleted pods
+		if int32(len(fakePodControl.Templates)) != 0 {
+			t.Errorf("%s: unexpected number of creates.  Expected 0, saw %d\n", name, len(fakePodControl.Templates))
+		}
+		if int32(len(fakePodControl.DeletePodName)) != tc.expectedDeletions {
+			t.Errorf("%s: unexpected number of deletes.  Expected %d, saw %d\n", name, tc.expectedDeletions, len(fakePodControl.DeletePodName))
+		}
+		// validate status
+		if actual.Status.Active != tc.expectedActive {
+			t.Errorf("%s: unexpected number of active pods.  Expected %d, saw %d\n", name, tc.expectedActive, actual.Status.Active)
+		}
+		if actual.Status.Succeeded != tc.expectedSucceeded {
+			t.Errorf("%s: unexpected number of succeeded pods.  Expected %d, saw %d\n", name, tc.expectedSucceeded, actual.Status.Succeeded)
+		}
+		if actual.Status.Failed != tc.expectedFailed {
+			t.Errorf("%s: unexpected number of failed pods.  Expected %d, saw %d\n", name, tc.expectedFailed, actual.Status.Failed)
+		}
+		if actual.Status.StartTime == nil {
+			t.Errorf("%s: .status.startTime was not set", name)
+		}
+		// validate conditions
+		if !getCondition(actual, batch.JobFailed) {
+			t.Errorf("%s: expected fail condition.  Got %#v", name, actual.Status.Conditions)
+		}
+	}
+}
+
+func getCondition(job *batch.Job, condition batch.JobConditionType) bool {
+	for _, v := range job.Status.Conditions {
+		if v.Type == condition && v.Status == v1.ConditionTrue {
+			return true
+		}
+	}
+	return false
+}
+
+func TestSyncPastDeadlineJobFinished(t *testing.T) {
+	clientset := clientset.NewForConfigOrDie(&restclient.Config{Host: "", ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+	manager, sharedInformerFactory := newJobControllerFromClient(clientset, controller.NoResyncPeriodFunc)
+	fakePodControl := controller.FakePodControl{}
+	manager.podControl = &fakePodControl
+	manager.podStoreSynced = alwaysReady
+	manager.jobStoreSynced = alwaysReady
+	var actual *batch.Job
+	manager.updateHandler = func(job *batch.Job) error {
+		actual = job
+		return nil
+	}
+
+	job := newJob(1, 1)
+	activeDeadlineSeconds := int64(10)
+	job.Spec.ActiveDeadlineSeconds = &activeDeadlineSeconds
+	start := metav1.Unix(metav1.Now().Time.Unix()-15, 0)
+	job.Status.StartTime = &start
+	job.Status.Conditions = append(job.Status.Conditions, newCondition(batch.JobFailed, "DeadlineExceeded", "Job was active longer than specified deadline"))
+	sharedInformerFactory.Jobs().Informer().GetIndexer().Add(job)
+	err := manager.syncJob(getKey(job, t))
+	if err != nil {
+		t.Errorf("Unexpected error when syncing jobs %v", err)
+	}
+	if len(fakePodControl.Templates) != 0 {
+		t.Errorf("Unexpected number of creates.  Expected %d, saw %d\n", 0, len(fakePodControl.Templates))
+	}
+	if len(fakePodControl.DeletePodName) != 0 {
+		t.Errorf("Unexpected number of deletes.  Expected %d, saw %d\n", 0, len(fakePodControl.DeletePodName))
+	}
+	if actual != nil {
+		t.Error("Unexpected job modification")
+	}
+}
+
+func TestSyncJobComplete(t *testing.T) {
+	clientset := clientset.NewForConfigOrDie(&restclient.Config{Host: "", ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+	manager, sharedInformerFactory := newJobControllerFromClient(clientset, controller.NoResyncPeriodFunc)
+	fakePodControl := controller.FakePodControl{}
+	manager.podControl = &fakePodControl
+	manager.podStoreSynced = alwaysReady
+	manager.jobStoreSynced = alwaysReady
+
+	job := newJob(1, 1)
+	job.Status.Conditions = append(job.Status.Conditions, newCondition(batch.JobComplete, "", ""))
+	sharedInformerFactory.Jobs().Informer().GetIndexer().Add(job)
+	err := manager.syncJob(getKey(job, t))
+	if err != nil {
+		t.Fatalf("Unexpected error when syncing jobs %v", err)
+	}
+	actual, err := manager.jobLister.Jobs(job.Namespace).Get(job.Name)
+	if err != nil {
+		t.Fatalf("Unexpected error when trying to get job from the store: %v", err)
+	}
+	// Verify that after syncing a complete job, the conditions are the same.
+	if got, expected := len(actual.Status.Conditions), 1; got != expected {
+		t.Fatalf("Unexpected job status conditions amount; expected %d, got %d", expected, got)
+	}
+}
+
+func TestSyncJobDeleted(t *testing.T) {
+	clientset := clientset.NewForConfigOrDie(&restclient.Config{Host: "", ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+	manager, _ := newJobControllerFromClient(clientset, controller.NoResyncPeriodFunc)
+	fakePodControl := controller.FakePodControl{}
+	manager.podControl = &fakePodControl
+	manager.podStoreSynced = alwaysReady
+	manager.jobStoreSynced = alwaysReady
+	manager.updateHandler = func(job *batch.Job) error { return nil }
+	job := newJob(2, 2)
+	err := manager.syncJob(getKey(job, t))
+	if err != nil {
+		t.Errorf("Unexpected error when syncing jobs %v", err)
+	}
+	if len(fakePodControl.Templates) != 0 {
+		t.Errorf("Unexpected number of creates.  Expected %d, saw %d\n", 0, len(fakePodControl.Templates))
+	}
+	if len(fakePodControl.DeletePodName) != 0 {
+		t.Errorf("Unexpected number of deletes.  Expected %d, saw %d\n", 0, len(fakePodControl.DeletePodName))
+	}
+}
+
+func TestSyncJobUpdateRequeue(t *testing.T) {
+	clientset := clientset.NewForConfigOrDie(&restclient.Config{Host: "", ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+	manager, sharedInformerFactory := newJobControllerFromClient(clientset, controller.NoResyncPeriodFunc)
+	fakePodControl := controller.FakePodControl{}
+	manager.podControl = &fakePodControl
+	manager.podStoreSynced = alwaysReady
+	manager.jobStoreSynced = alwaysReady
+	updateError := fmt.Errorf("Update error")
+	manager.updateHandler = func(job *batch.Job) error {
+		manager.queue.AddRateLimited(getKey(job, t))
+		return updateError
+	}
+	job := newJob(2, 2)
+	sharedInformerFactory.Jobs().Informer().GetIndexer().Add(job)
+	err := manager.syncJob(getKey(job, t))
+	if err == nil || err != updateError {
+		t.Errorf("Expected error %v when syncing jobs, got %v", updateError, err)
+	}
+	t.Log("Waiting for a job in the queue")
+	key, _ := manager.queue.Get()
+	expectedKey := getKey(job, t)
+	if key != expectedKey {
+		t.Errorf("Expected requeue of job with key %s got %s", expectedKey, key)
+	}
+}
+
+func TestJobPodLookup(t *testing.T) {
+	clientset := clientset.NewForConfigOrDie(&restclient.Config{Host: "", ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+	manager, sharedInformerFactory := newJobControllerFromClient(clientset, controller.NoResyncPeriodFunc)
+	manager.podStoreSynced = alwaysReady
+	manager.jobStoreSynced = alwaysReady
+	testCases := []struct {
+		job *batch.Job
+		pod *v1.Pod
+
+		expectedName string
+	}{
+		// pods without labels don't match any job
+		{
+			job: &batch.Job{
+				ObjectMeta: v1.ObjectMeta{Name: "basic"},
+			},
+			pod: &v1.Pod{
+				ObjectMeta: v1.ObjectMeta{Name: "foo1", Namespace: v1.NamespaceAll},
+			},
+			expectedName: "",
+		},
+		// matching labels, different namespace
+		{
+			job: &batch.Job{
+				ObjectMeta: v1.ObjectMeta{Name: "foo"},
+				Spec: batch.JobSpec{
+					Selector: &metav1.LabelSelector{
+						MatchLabels: map[string]string{"foo": "bar"},
+					},
+				},
+			},
+			pod: &v1.Pod{
+				ObjectMeta: v1.ObjectMeta{
+					Name:      "foo2",
+					Namespace: "ns",
+					Labels:    map[string]string{"foo": "bar"},
+				},
+			},
+			expectedName: "",
+		},
+		// matching ns and labels returns
+		{
+			job: &batch.Job{
+				ObjectMeta: v1.ObjectMeta{Name: "bar", Namespace: "ns"},
+				Spec: batch.JobSpec{
+					Selector: &metav1.LabelSelector{
+						MatchExpressions: []metav1.LabelSelectorRequirement{
+							{
+								Key:      "foo",
+								Operator: metav1.LabelSelectorOpIn,
+								Values:   []string{"bar"},
+							},
+						},
+					},
+				},
+			},
+			pod: &v1.Pod{
+				ObjectMeta: v1.ObjectMeta{
+					Name:      "foo3",
+					Namespace: "ns",
+					Labels:    map[string]string{"foo": "bar"},
+				},
+			},
+			expectedName: "bar",
+		},
+	}
+	for _, tc := range testCases {
+		sharedInformerFactory.Jobs().Informer().GetIndexer().Add(tc.job)
+		if job := manager.getPodJob(tc.pod); job != nil {
+			if tc.expectedName != job.Name {
+				t.Errorf("Got job %+v expected %+v", job.Name, tc.expectedName)
+			}
+		} else if tc.expectedName != "" {
+			t.Errorf("Expected a job %v pod %v, found none", tc.expectedName, tc.pod.Name)
+		}
+	}
+}
+
+type FakeJobExpectations struct {
+	*controller.ControllerExpectations
+	satisfied    bool
+	expSatisfied func()
+}
+
+func (fe FakeJobExpectations) SatisfiedExpectations(controllerKey string) bool {
+	fe.expSatisfied()
+	return fe.satisfied
+}
+
+// TestSyncJobExpectations tests that a pod cannot sneak in between counting active pods
+// and checking expectations.
+func TestSyncJobExpectations(t *testing.T) {
+	clientset := clientset.NewForConfigOrDie(&restclient.Config{Host: "", ContentConfig: restclient.ContentConfig{GroupVersion: &api.Registry.GroupOrDie(v1.GroupName).GroupVersion}})
+	manager, sharedInformerFactory := newJobControllerFromClient(clientset, controller.NoResyncPeriodFunc)
+	fakePodControl := controller.FakePodControl{}
+	manager.podControl = &fakePodControl
+	manager.podStoreSynced = alwaysReady
+	manager.jobStoreSynced = alwaysReady
+	manager.updateHandler = func(job *batch.Job) error { return nil }
+
+	job := newJob(2, 2)
+	sharedInformerFactory.Jobs().Informer().GetIndexer().Add(job)
+	pods := newPodList(2, v1.PodPending, job)
+	podIndexer := sharedInformerFactory.Pods().Informer().GetIndexer()
+	podIndexer.Add(&pods[0])
+
+	manager.expectations = FakeJobExpectations{
+		controller.NewControllerExpectations(), true, func() {
+			// If we check active pods before checking expectataions, the job
+			// will create a new replica because it doesn't see this pod, but
+			// has fulfilled its expectations.
+			podIndexer.Add(&pods[1])
+		},
+	}
+	manager.syncJob(getKey(job, t))
+	if len(fakePodControl.Templates) != 0 {
+		t.Errorf("Unexpected number of creates.  Expected %d, saw %d\n", 0, len(fakePodControl.Templates))
+	}
+	if len(fakePodControl.DeletePodName) != 0 {
+		t.Errorf("Unexpected number of deletes.  Expected %d, saw %d\n", 0, len(fakePodControl.DeletePodName))
+	}
+}
+
+func TestWatchJobs(t *testing.T) {
+	clientset := fake.NewSimpleClientset()
+	fakeWatch := watch.NewFake()
+	clientset.PrependWatchReactor("jobs", core.DefaultWatchReactor(fakeWatch, nil))
+	manager, sharedInformerFactory := newJobControllerFromClient(clientset, controller.NoResyncPeriodFunc)
+	manager.podStoreSynced = alwaysReady
+	manager.jobStoreSynced = alwaysReady
+
+	var testJob batch.Job
+	received := make(chan struct{})
+
+	// The update sent through the fakeWatcher should make its way into the workqueue,
+	// and eventually into the syncHandler.
+	manager.syncHandler = func(key string) error {
+		defer close(received)
+		ns, name, err := cache.SplitMetaNamespaceKey(key)
+		if err != nil {
+			t.Errorf("Error getting namespace/name from key %v: %v", key, err)
+		}
+		job, err := manager.jobLister.Jobs(ns).Get(name)
+		if err != nil || job == nil {
+			t.Errorf("Expected to find job under key %v: %v", key, err)
+			return nil
+		}
+		if !api.Semantic.DeepDerivative(*job, testJob) {
+			t.Errorf("Expected %#v, but got %#v", testJob, *job)
+		}
+		return nil
+	}
+	// Start only the job watcher and the workqueue, send a watch event,
+	// and make sure it hits the sync method.
+	stopCh := make(chan struct{})
+	defer close(stopCh)
+	sharedInformerFactory.Start(stopCh)
+	go manager.Run(1, stopCh)
+
+	// We're sending new job to see if it reaches syncHandler.
+	testJob.Namespace = "bar"
+	testJob.Name = "foo"
+	fakeWatch.Add(&testJob)
+	t.Log("Waiting for job to reach syncHandler")
+	<-received
+}
+
+func TestWatchPods(t *testing.T) {
+	testJob := newJob(2, 2)
+	clientset := fake.NewSimpleClientset(testJob)
+	fakeWatch := watch.NewFake()
+	clientset.PrependWatchReactor("pods", core.DefaultWatchReactor(fakeWatch, nil))
+	manager, sharedInformerFactory := newJobControllerFromClient(clientset, controller.NoResyncPeriodFunc)
+	manager.podStoreSynced = alwaysReady
+	manager.jobStoreSynced = alwaysReady
+
+	// Put one job and one pod into the store
+	sharedInformerFactory.Jobs().Informer().GetIndexer().Add(testJob)
+	received := make(chan struct{})
+	// The pod update sent through the fakeWatcher should figure out the managing job and
+	// send it into the syncHandler.
+	manager.syncHandler = func(key string) error {
+		ns, name, err := cache.SplitMetaNamespaceKey(key)
+		if err != nil {
+			t.Errorf("Error getting namespace/name from key %v: %v", key, err)
+		}
+		job, err := manager.jobLister.Jobs(ns).Get(name)
+		if err != nil {
+			t.Errorf("Expected to find job under key %v: %v", key, err)
+		}
+		if !api.Semantic.DeepDerivative(job, testJob) {
+			t.Errorf("\nExpected %#v,\nbut got %#v", testJob, job)
+			close(received)
+			return nil
+		}
+		close(received)
+		return nil
+	}
+	// Start only the pod watcher and the workqueue, send a watch event,
+	// and make sure it hits the sync method for the right job.
+	stopCh := make(chan struct{})
+	defer close(stopCh)
+	go sharedInformerFactory.Pods().Informer().Run(stopCh)
+	go wait.Until(manager.worker, 10*time.Millisecond, stopCh)
+
+	pods := newPodList(1, v1.PodRunning, testJob)
+	testPod := pods[0]
+	testPod.Status.Phase = v1.PodFailed
+	fakeWatch.Add(&testPod)
+
+	t.Log("Waiting for pod to reach syncHandler")
+	<-received
+}

vendor/k8s.io/kubernetes/pkg/controller/job/utils.go

@@ -0,0 +1,31 @@
+/*
+Copyright 2016 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.
+*/
+
+package job
+
+import (
+	"k8s.io/kubernetes/pkg/api/v1"
+	batch "k8s.io/kubernetes/pkg/apis/batch/v1"
+)
+
+func IsJobFinished(j *batch.Job) bool {
+	for _, c := range j.Status.Conditions {
+		if (c.Type == batch.JobComplete || c.Type == batch.JobFailed) && c.Status == v1.ConditionTrue {
+			return true
+		}
+	}
+	return false
+}

vendor/k8s.io/kubernetes/pkg/controller/job/utils_test.go

@@ -0,0 +1,49 @@
+/*
+Copyright 2016 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.
+*/
+
+package job
+
+import (
+	"testing"
+
+	"k8s.io/kubernetes/pkg/api/v1"
+	batch "k8s.io/kubernetes/pkg/apis/batch/v1"
+)
+
+func TestIsJobFinished(t *testing.T) {
+	job := &batch.Job{
+		Status: batch.JobStatus{
+			Conditions: []batch.JobCondition{{
+				Type:   batch.JobComplete,
+				Status: v1.ConditionTrue,
+			}},
+		},
+	}
+
+	if !IsJobFinished(job) {
+		t.Error("Job was expected to be finished")
+	}
+
+	job.Status.Conditions[0].Status = v1.ConditionFalse
+	if IsJobFinished(job) {
+		t.Error("Job was not expected to be finished")
+	}
+
+	job.Status.Conditions[0].Status = v1.ConditionUnknown
+	if IsJobFinished(job) {
+		t.Error("Job was not expected to be finished")
+	}
+}