Port pod interval test json files and fix resulting bugs

Author: dgoodwin

pkg/monitor/monitorapi/identification_pod.go

@@ -13,10 +13,6 @@ func LocatePod(pod *corev1.Pod) string {
 	return fmt.Sprintf("ns/%s pod/%s node/%s uid/%s", pod.Namespace, pod.Name, pod.Spec.NodeName, pod.UID)
 }
 
-func LocatePodContainer(pod *corev1.Pod, containerName string) string {
-	return fmt.Sprintf("ns/%s pod/%s node/%s uid/%s container/%s", pod.Namespace, pod.Name, pod.Spec.NodeName, pod.UID, containerName)
-}
-
 // NonUniquePodLocatorFrom produces an inexact locator based on namespace and name.  This is useful when dealing with events
 // that are produced that do not contain UIDs.  Ultimately, we should use UIDs everywhere, but this is will keep some our
 // matching working until then.
@@ -26,6 +22,7 @@ func NonUniquePodLocatorFrom(locator string) string {
 	return fmt.Sprintf("ns/%s pod/%s", namespace, parts["pod"])
 }
 
+// TODO:  all callers should eventuall be using structured locator variant below:
 func PodFrom(locator string) PodReference {
 	parts := LocatorParts(locator)
 	namespace := NamespaceFrom(parts)
@@ -43,10 +40,27 @@ func PodFrom(locator string) PodReference {
 	}
 }
 
-func ContainerFrom(locator string) ContainerReference {
-	pod := PodFrom(locator)
-	parts := LocatorParts(locator)
-	name := parts["container"]
+// PodFromLocator is used to strip down a locator to just a pod. (as it may contain additional keys like container or node)
+// that we do not want for some uses.
+func PodFromLocator(locator Locator) PodReference {
+	namespace := locator.Keys[LocatorNamespaceKey]
+	name := locator.Keys[LocatorPodKey]
+	uid := locator.Keys[LocatorUIDKey]
+	if len(namespace) == 0 || len(name) == 0 {
+		return PodReference{}
+	}
+	return PodReference{
+		NamespacedReference: NamespacedReference{
+			Namespace: namespace,
+			Name:      name,
+			UID:       uid,
+		},
+	}
+}
+
+func ContainerFrom(locator Locator) ContainerReference {
+	pod := PodFrom(locator.OldLocator())
+	name := locator.Keys[LocatorContainerKey]
 	if len(name) == 0 || len(pod.UID) == 0 {
 		return ContainerReference{}
 	}
@@ -61,17 +75,17 @@ type PodReference struct {
 	NamespacedReference
 }
 
-func (r PodReference) ToLocator() string {
-	return fmt.Sprintf("ns/%s pod/%s uid/%s", r.Namespace, r.Name, r.UID)
+func (r PodReference) ToLocator() Locator {
+	return NewLocator().PodFromNames(r.Namespace, r.Name, r.UID)
 }
 
 type ContainerReference struct {
 	Pod           PodReference
 	ContainerName string
 }
 
-func (r ContainerReference) ToLocator() string {
-	return fmt.Sprintf("ns/%s pod/%s uid/%s container/%s", r.Pod.Namespace, r.Pod.Name, r.Pod.UID, r.ContainerName)
+func (r ContainerReference) ToLocator() Locator {
+	return NewLocator().ContainerFromNames(r.Pod.Namespace, r.Pod.Name, r.Pod.UID, r.ContainerName)
 }
 
 func AnnotationsFromMessage(message string) map[AnnotationKey]string {

pkg/monitor/monitorapi/types.go

@@ -370,26 +370,18 @@ type Intervals []Interval
 var _ sort.Interface = Intervals{}
 
 func (intervals Intervals) Less(i, j int) bool {
-	fmt.Printf("comparing\n")
-	fmt.Printf("    %+v\n", intervals[i])
-	fmt.Printf("    %+v\n", intervals[j])
 	switch d := intervals[i].From.Sub(intervals[j].From); {
 	case d < 0:
-		fmt.Println("    from less than, returning true")
 		return true
 	case d > 0:
-		fmt.Println("    from greater than, returning false")
 		return false
 	}
 	switch d := intervals[i].To.Sub(intervals[j].To); {
 	case d < 0:
-		fmt.Println("    to less than, returning true")
 		return true
 	case d > 0:
-		fmt.Println("    to greater than, returning false")
 		return false
 	}
-	fmt.Printf("    falling back to message comparison: %v\n", intervals[i].Message < intervals[j].Message)
 	return intervals[i].Message < intervals[j].Message
 }
 func (intervals Intervals) Len() int { return len(intervals) }

pkg/monitortestlibrary/statetracker/state_tracker.go

@@ -148,7 +148,6 @@ func (t *stateTracker) CloseInterval(locator monitorapi.Locator, state StateInfo
 	if !hasCondition {
 		return nil
 	}
-	// TODO: from/to and Build needed?
 	return []monitorapi.Interval{ib.Build(from, to)}
 }