func addPods(store cache.Store, namespace string, nPods int, nPorts int, nNotReady int) { for i := 0; i < nPods+nNotReady; i++ { p := &api.Pod{ TypeMeta: unversioned.TypeMeta{APIVersion: testapi.Default.Version()}, ObjectMeta: api.ObjectMeta{ Namespace: namespace, Name: fmt.Sprintf("pod%d", i), Labels: map[string]string{"foo": "bar"}, }, Spec: api.PodSpec{ Containers: []api.Container{{Ports: []api.ContainerPort{}}}, }, Status: api.PodStatus{ PodIP: fmt.Sprintf("1.2.3.%d", 4+i), Conditions: []api.PodCondition{ { Type: api.PodReady, Status: api.ConditionTrue, }, }, }, } if i >= nPods { p.Status.Conditions[0].Status = api.ConditionFalse } for j := 0; j < nPorts; j++ { p.Spec.Containers[0].Ports = append(p.Spec.Containers[0].Ports, api.ContainerPort{Name: fmt.Sprintf("port%d", i), ContainerPort: 8080 + j}) } store.Add(p) } }
// cacheReviewRecord updates the cache based on the request processed func cacheReviewRecord(request *reviewRequest, lastKnownValue *reviewRecord, review Review, reviewRecordStore cache.Store) { reviewRecord := &reviewRecord{ reviewRequest: &reviewRequest{namespace: request.namespace, policyUIDToResourceVersion: map[types.UID]string{}, policyBindingUIDToResourceVersion: map[types.UID]string{}}, groups: review.Groups(), users: review.Users(), } // keep what we last believe we knew by default if lastKnownValue != nil { reviewRecord.namespaceResourceVersion = lastKnownValue.namespaceResourceVersion for k, v := range lastKnownValue.policyUIDToResourceVersion { reviewRecord.policyUIDToResourceVersion[k] = v } for k, v := range lastKnownValue.policyBindingUIDToResourceVersion { reviewRecord.policyBindingUIDToResourceVersion[k] = v } } // update the review record relative to what drove this request if len(request.namespaceResourceVersion) > 0 { reviewRecord.namespaceResourceVersion = request.namespaceResourceVersion } for k, v := range request.policyUIDToResourceVersion { reviewRecord.policyUIDToResourceVersion[k] = v } for k, v := range request.policyBindingUIDToResourceVersion { reviewRecord.policyBindingUIDToResourceVersion[k] = v } // update the cache record reviewRecordStore.Add(reviewRecord) }
func addPods(store cache.Store, namespace string, nPods int, nPorts int, nNotReady int) { for i := 0; i < nPods+nNotReady; i++ { p := &v1.Pod{ TypeMeta: metav1.TypeMeta{APIVersion: registered.GroupOrDie(v1.GroupName).GroupVersion.String()}, ObjectMeta: v1.ObjectMeta{ Namespace: namespace, Name: fmt.Sprintf("pod%d", i), Labels: map[string]string{"foo": "bar"}, }, Spec: v1.PodSpec{ Containers: []v1.Container{{Ports: []v1.ContainerPort{}}}, }, Status: v1.PodStatus{ PodIP: fmt.Sprintf("1.2.3.%d", 4+i), Conditions: []v1.PodCondition{ { Type: v1.PodReady, Status: v1.ConditionTrue, }, }, }, } if i >= nPods { p.Status.Conditions[0].Status = v1.ConditionFalse } for j := 0; j < nPorts; j++ { p.Spec.Containers[0].Ports = append(p.Spec.Containers[0].Ports, v1.ContainerPort{Name: fmt.Sprintf("port%d", i), ContainerPort: int32(8080 + j)}) } store.Add(p) } }
// addSubjectsToNamespace adds the specified namespace to each subject func addSubjectsToNamespace(subjectRecordStore cache.Store, subjects []string, namespace string) { for _, subject := range subjects { var item *subjectRecord obj, exists, _ := subjectRecordStore.GetByKey(subject) if exists { item = obj.(*subjectRecord) } else { item = &subjectRecord{subject: subject, namespaces: sets.NewString()} subjectRecordStore.Add(item) } item.namespaces.Insert(namespace) } }
// storeObjectUpdate updates given cache with a new object version from Informer // callback (i.e. with events from etcd) or with an object modified by the // controller itself. Returns "true", if the cache was updated, false if the // object is an old version and should be ignored. func storeObjectUpdate(store cache.Store, obj interface{}, className string) (bool, error) { objName, err := controller.KeyFunc(obj) if err != nil { return false, fmt.Errorf("Couldn't get key for object %+v: %v", obj, err) } oldObj, found, err := store.Get(obj) if err != nil { return false, fmt.Errorf("Error finding %s %q in controller cache: %v", className, objName, err) } objAccessor, err := meta.Accessor(obj) if err != nil { return false, err } if !found { // This is a new object glog.V(4).Infof("storeObjectUpdate: adding %s %q, version %s", className, objName, objAccessor.GetResourceVersion()) if err = store.Add(obj); err != nil { return false, fmt.Errorf("Error adding %s %q to controller cache: %v", className, objName, err) } return true, nil } oldObjAccessor, err := meta.Accessor(oldObj) if err != nil { return false, err } objResourceVersion, err := strconv.ParseInt(objAccessor.GetResourceVersion(), 10, 64) if err != nil { return false, fmt.Errorf("Error parsing ResourceVersion %q of %s %q: %s", objAccessor.GetResourceVersion(), className, objName, err) } oldObjResourceVersion, err := strconv.ParseInt(oldObjAccessor.GetResourceVersion(), 10, 64) if err != nil { return false, fmt.Errorf("Error parsing old ResourceVersion %q of %s %q: %s", oldObjAccessor.GetResourceVersion(), className, objName, err) } // Throw away only older version, let the same version pass - we do want to // get periodic sync events. if oldObjResourceVersion > objResourceVersion { glog.V(4).Infof("storeObjectUpdate: ignoring %s %q version %s", className, objName, objAccessor.GetResourceVersion()) return false, nil } glog.V(4).Infof("storeObjectUpdate updating %s %q with version %s", className, objName, objAccessor.GetResourceVersion()) if err = store.Update(obj); err != nil { return false, fmt.Errorf("Error updating %s %q in controller cache: %v", className, objName, err) } return true, nil }
// create count pods with the given phase for the given rc (same selectors and namespace), and add them to the store. func newPodList(store cache.Store, count int, status api.PodPhase, rc *api.ReplicationController, name string) *api.PodList { pods := []api.Pod{} var trueVar = true controllerReference := api.OwnerReference{UID: rc.UID, APIVersion: "v1", Kind: "ReplicationController", Name: rc.Name, Controller: &trueVar} for i := 0; i < count; i++ { pod := newPod(fmt.Sprintf("%s%d", name, i), rc, status) pod.OwnerReferences = []api.OwnerReference{controllerReference} if store != nil { store.Add(pod) } pods = append(pods, *pod) } return &api.PodList{ Items: pods, } }
// create count pods with the given phase for the given ReplicaSet (same selectors and namespace), and add them to the store. func newPodList(store cache.Store, count int, status api.PodPhase, labelMap map[string]string, rs *extensions.ReplicaSet, name string) *api.PodList { pods := []api.Pod{} var trueVar = true controllerReference := api.OwnerReference{UID: rs.UID, APIVersion: "v1beta1", Kind: "ReplicaSet", Name: rs.Name, Controller: &trueVar} for i := 0; i < count; i++ { pod := newPod(fmt.Sprintf("%s%d", name, i), rs, status) pod.ObjectMeta.Labels = labelMap pod.OwnerReferences = []api.OwnerReference{controllerReference} if store != nil { store.Add(pod) } pods = append(pods, *pod) } return &api.PodList{ Items: pods, } }
// create count pods with the given phase for the given ReplicaSet (same selectors and namespace), and add them to the store. func newPodList(store cache.Store, count int, status api.PodPhase, labelMap map[string]string, rs *extensions.ReplicaSet) *api.PodList { pods := []api.Pod{} for i := 0; i < count; i++ { newPod := api.Pod{ ObjectMeta: api.ObjectMeta{ Name: fmt.Sprintf("pod%d", i), Labels: labelMap, Namespace: rs.Namespace, }, Status: api.PodStatus{Phase: status}, } if store != nil { store.Add(&newPod) } pods = append(pods, newPod) } return &api.PodList{ Items: pods, } }
// create count pods with the given phase for the given rc (same selectors and namespace), and add them to the store. func newPodList(store cache.Store, count int, status api.PodPhase, rc *api.ReplicationController, name string) *api.PodList { pods := []api.Pod{} for i := 0; i < count; i++ { newPod := api.Pod{ ObjectMeta: api.ObjectMeta{ Name: fmt.Sprintf("%s%d", name, i), Labels: rc.Spec.Selector, Namespace: rc.Namespace, }, Status: api.PodStatus{Phase: status}, } if store != nil { store.Add(&newPod) } pods = append(pods, newPod) } return &api.PodList{ Items: pods, } }
// create count pods with the given phase for the given rc (same selectors and namespace), and add them to the store. func newPodList(store cache.Store, count int, status v1.PodPhase, rc *v1.ReplicationController) *v1.PodList { pods := []v1.Pod{} for i := 0; i < count; i++ { newPod := v1.Pod{ ObjectMeta: metav1.ObjectMeta{ Name: fmt.Sprintf("pod%d", i), Labels: rc.Spec.Selector, Namespace: rc.Namespace, }, Status: v1.PodStatus{Phase: status}, } if store != nil { store.Add(&newPod) } pods = append(pods, newPod) } return &v1.PodList{ Items: pods, } }
func addNodes(nodeStore cache.Store, startIndex, numNodes int, label map[string]string) { for i := startIndex; i < startIndex+numNodes; i++ { nodeStore.Add(newNode(fmt.Sprintf("node-%d", i), label)) } }
func addPods(podStore cache.Store, nodeName string, label map[string]string, number int) { for i := 0; i < number; i++ { podStore.Add(newPod(fmt.Sprintf("%s-", nodeName), nodeName, label)) } }
func add(t *testing.T, store cache.Store, obj interface{}) { if err := store.Add(obj); err != nil { t.Fatalf("Could not add %+v to %+v: %v", obj, store, err) } }