Merge pull request #71 from replicatedhq/divolgin/output-names

divolgin · web-flow · commit 36e3bf294d1a · 2019-10-24T11:31:45.000-07:00
support multiple containers in pod logs
diff --git a/cmd/troubleshoot/cli/run_nocrd.go b/cmd/troubleshoot/cli/run_nocrd.go
@@ -179,18 +179,21 @@ func runCollectors(v *viper.Viper, collector troubleshootv1beta1.Collector, prog
 			continue
 		}
 
-		collectorDir, err := parseAndSaveCollectorOutput(string(result), bundlePath)
+		newCollectorDirs, err := parseAndSaveCollectorOutput(string(result), bundlePath)
 		if err != nil {
 			progressChan <- fmt.Errorf("failed to parse collector spec %q: %v", collector.GetDisplayName(), err)
 			continue
 		}
 
-		if collectorDir == "" {
+		if len(newCollectorDirs) == 0 {
 			continue
 		}
 
-		progressChan <- collectorDir
-		collectorDirs = append(collectorDirs, collectorDir)
+		// TODO: better progress....
+		for _, d := range newCollectorDirs {
+			progressChan <- d
+		}
+		collectorDirs = append(collectorDirs, newCollectorDirs...)
 	}
 
 	tarGz := archiver.TarGz{
@@ -219,53 +222,58 @@ func runCollectors(v *viper.Viper, collector troubleshootv1beta1.Collector, prog
 	return filename, nil
 }
 
-func parseAndSaveCollectorOutput(output string, bundlePath string) (string, error) {
-	dir := ""
+func parseAndSaveCollectorOutput(output string, bundlePath string) ([]string, error) {
+	rootDirs := make(map[string]bool)
 
 	input := make(map[string]interface{})
 	if err := json.Unmarshal([]byte(output), &input); err != nil {
-		return "", errors.Wrap(err, "unmarshal output")
+		return nil, errors.Wrap(err, "unmarshal output")
 	}
 
 	for filename, maybeContents := range input {
 		fileDir, fileName := filepath.Split(filename)
 		outPath := filepath.Join(bundlePath, fileDir)
-		dir = outPath
+		rootDirs[outPath] = true
 
 		if err := os.MkdirAll(outPath, 0777); err != nil {
-			return "", errors.Wrap(err, "create output file")
+			return nil, errors.Wrap(err, "create output file")
 		}
 
 		switch maybeContents.(type) {
 		case string:
 			decoded, err := base64.StdEncoding.DecodeString(maybeContents.(string))
 			if err != nil {
-				return "", errors.Wrap(err, "decode collector output")
+				return nil, errors.Wrap(err, "decode collector output")
 			}
 
 			if err := writeFile(filepath.Join(outPath, fileName), decoded); err != nil {
-				return "", errors.Wrap(err, "write collector output")
+				return nil, errors.Wrap(err, "write collector output")
 			}
 
 		case map[string]interface{}:
 			for k, v := range maybeContents.(map[string]interface{}) {
 				s, _ := filepath.Split(filepath.Join(outPath, fileName, k))
 				if err := os.MkdirAll(s, 0777); err != nil {
-					return "", errors.Wrap(err, "write output directories")
+					return nil, errors.Wrap(err, "write output directories")
 				}
 
 				decoded, err := base64.StdEncoding.DecodeString(v.(string))
 				if err != nil {
-					return "", errors.Wrap(err, "decode output")
+					return nil, errors.Wrap(err, "decode output")
 				}
 				if err := writeFile(filepath.Join(outPath, fileName, k), decoded); err != nil {
-					return "", errors.Wrap(err, "write output")
+					return nil, errors.Wrap(err, "write output")
 				}
 			}
 		}
 	}
 
-	return dir, nil
+	dirs := make([]string, 0)
+	for dir := range rootDirs {
+		dirs = append(dirs, dir)
+	}
+
+	return dirs, nil
 }
 
 func uploadSupportBundle(r *troubleshootv1beta1.ResultRequest, archivePath string) error {
diff --git a/pkg/apis/troubleshoot/v1beta1/collector_shared.go b/pkg/apis/troubleshoot/v1beta1/collector_shared.go
@@ -27,6 +27,7 @@ type Logs struct {
 	CollectorMeta `json:",inline" yaml:",inline"`
 	Selector      []string   `json:"selector" yaml:"selector"`
 	Namespace     string     `json:"namespace,omitempty" yaml:"namespace,omitempty"`
+	Containers    []string   `json:"containers,omitempty" yaml:"containers,omitempty"`
 	Limits        *LogLimits `json:"limits,omitempty" yaml:"omitempty"`
 }
 
diff --git a/pkg/apis/troubleshoot/v1beta1/zz_generated.deepcopy.go b/pkg/apis/troubleshoot/v1beta1/zz_generated.deepcopy.go
@@ -882,6 +882,11 @@ func (in *Logs) DeepCopyInto(out *Logs) {
 		*out = make([]string, len(*in))
 		copy(*out, *in)
 	}
+	if in.Containers != nil {
+		in, out := &in.Containers, &out.Containers
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
 	if in.Limits != nil {
 		in, out := &in.Limits, &out.Limits
 		*out = new(LogLimits)
diff --git a/pkg/collect/logs.go b/pkg/collect/logs.go
@@ -42,18 +42,34 @@ func Logs(ctx *Context, logsCollector *troubleshootv1beta1.Logs) ([]byte, error)
 
 	if len(pods) > 0 {
 		for _, pod := range pods {
-			podLogs, err := getPodLogs(client, pod, logsCollector.Limits, false)
-			if err != nil {
-				key := fmt.Sprintf("%s/%s-errors.json", pod.Namespace, pod.Name)
-				logsOutput.Errors[key], err = marshalNonNil([]string{err.Error()})
+			if len(logsCollector.Containers) == 0 {
+				podLogs, err := getPodLogs(client, pod, "", logsCollector.Limits, false)
 				if err != nil {
-					return nil, err
+					key := fmt.Sprintf("%s/%s-errors.json", pod.Namespace, pod.Name)
+					logsOutput.Errors[key], err = marshalNonNil([]string{err.Error()})
+					if err != nil {
+						return nil, err
+					}
+					continue
+				}
+				for k, v := range podLogs {
+					logsOutput.PodLogs[k] = v
+				}
+			} else {
+				for _, container := range logsCollector.Containers {
+					containerLogs, err := getPodLogs(client, pod, container, logsCollector.Limits, false)
+					if err != nil {
+						key := fmt.Sprintf("%s/%s/%s-errors.json", pod.Namespace, pod.Name, container)
+						logsOutput.Errors[key], err = marshalNonNil([]string{err.Error()})
+						if err != nil {
+							return nil, err
+						}
+						continue
+					}
+					for k, v := range containerLogs {
+						logsOutput.PodLogs[k] = v
+					}
 				}
-				continue
-			}
-
-			for k, v := range podLogs {
-				logsOutput.PodLogs[k] = v
 			}
 		}
 
@@ -88,9 +104,10 @@ func listPodsInSelectors(client *kubernetes.Clientset, namespace string, selecto
 	return pods.Items, nil
 }
 
-func getPodLogs(client *kubernetes.Clientset, pod corev1.Pod, limits *troubleshootv1beta1.LogLimits, follow bool) (map[string][]byte, error) {
+func getPodLogs(client *kubernetes.Clientset, pod corev1.Pod, container string, limits *troubleshootv1beta1.LogLimits, follow bool) (map[string][]byte, error) {
 	podLogOpts := corev1.PodLogOptions{
-		Follow: follow,
+		Follow:    follow,
+		Container: container,
 	}
 
 	defaultMaxLines := int64(10000)
@@ -126,8 +143,13 @@ func getPodLogs(client *kubernetes.Clientset, pod corev1.Pod, limits *troublesho
 		return nil, err
 	}
 
+	fileKey := fmt.Sprintf("%s/%s.txt", pod.Namespace, pod.Name)
+	if container != "" {
+		fileKey = fmt.Sprintf("%s/%s/%s.txt", pod.Namespace, pod.Name, container)
+	}
+
 	return map[string][]byte{
-		fmt.Sprintf("%s/%s.txt", pod.Namespace, pod.Name): buf.Bytes(),
+		fileKey: buf.Bytes(),
 	}, nil
 }
 
diff --git a/pkg/collect/run.go b/pkg/collect/run.go
@@ -89,7 +89,7 @@ func runWithoutTimeout(ctx *Context, pod *corev1.Pod, runCollector *troubleshoot
 	limits := troubleshootv1beta1.LogLimits{
 		MaxLines: 10000,
 	}
-	podLogs, err := getPodLogs(client, *pod, &limits, true)
+	podLogs, err := getPodLogs(client, *pod, "", &limits, true)
 
 	for k, v := range podLogs {
 		runOutput.PodLogs[k] = v

Original file line number	Diff line number	Diff line change
`@@ -179,18 +179,21 @@ func runCollectors(v *viper.Viper, collector troubleshootv1beta1.Collector, prog`
`179`	`179`	`continue`
`180`	`180`	`}`
`181`	`181`
`182`		`- collectorDir, err := parseAndSaveCollectorOutput(string(result), bundlePath)`
	`182`	`+ newCollectorDirs, err := parseAndSaveCollectorOutput(string(result), bundlePath)`
`183`	`183`	`if err != nil {`
`184`	`184`	`progressChan <- fmt.Errorf("failed to parse collector spec %q: %v", collector.GetDisplayName(), err)`
`185`	`185`	`continue`
`186`	`186`	`}`
`187`	`187`
`188`		`- if collectorDir == "" {`
	`188`	`+ if len(newCollectorDirs) == 0 {`
`189`	`189`	`continue`
`190`	`190`	`}`
`191`	`191`
`192`		`- progressChan <- collectorDir`
`193`		`- collectorDirs = append(collectorDirs, collectorDir)`
	`192`	`+ // TODO: better progress....`
	`193`	`+ for _, d := range newCollectorDirs {`
	`194`	`+ progressChan <- d`
	`195`	`+ }`
	`196`	`+ collectorDirs = append(collectorDirs, newCollectorDirs...)`
`194`	`197`	`}`
`195`	`198`
`196`	`199`	`tarGz := archiver.TarGz{`
`@@ -219,53 +222,58 @@ func runCollectors(v *viper.Viper, collector troubleshootv1beta1.Collector, prog`
`219`	`222`	`return filename, nil`
`220`	`223`	`}`
`221`	`224`
`222`		`-func parseAndSaveCollectorOutput(output string, bundlePath string) (string, error) {`
`223`		`- dir := ""`
	`225`	`+func parseAndSaveCollectorOutput(output string, bundlePath string) ([]string, error) {`
	`226`	`+ rootDirs := make(map[string]bool)`
`224`	`227`
`225`	`228`	`input := make(map[string]interface{})`
`226`	`229`	`if err := json.Unmarshal([]byte(output), &input); err != nil {`
`227`		`- return "", errors.Wrap(err, "unmarshal output")`
	`230`	`+ return nil, errors.Wrap(err, "unmarshal output")`
`228`	`231`	`}`
`229`	`232`
`230`	`233`	`for filename, maybeContents := range input {`
`231`	`234`	`fileDir, fileName := filepath.Split(filename)`
`232`	`235`	`outPath := filepath.Join(bundlePath, fileDir)`
`233`		`- dir = outPath`
	`236`	`+ rootDirs[outPath] = true`
`234`	`237`
`235`	`238`	`if err := os.MkdirAll(outPath, 0777); err != nil {`
`236`		`- return "", errors.Wrap(err, "create output file")`
	`239`	`+ return nil, errors.Wrap(err, "create output file")`
`237`	`240`	`}`
`238`	`241`
`239`	`242`	`switch maybeContents.(type) {`
`240`	`243`	`case string:`
`241`	`244`	`decoded, err := base64.StdEncoding.DecodeString(maybeContents.(string))`
`242`	`245`	`if err != nil {`
`243`		`- return "", errors.Wrap(err, "decode collector output")`
	`246`	`+ return nil, errors.Wrap(err, "decode collector output")`
`244`	`247`	`}`
`245`	`248`
`246`	`249`	`if err := writeFile(filepath.Join(outPath, fileName), decoded); err != nil {`
`247`		`- return "", errors.Wrap(err, "write collector output")`
	`250`	`+ return nil, errors.Wrap(err, "write collector output")`
`248`	`251`	`}`
`249`	`252`
`250`	`253`	`case map[string]interface{}:`
`251`	`254`	`for k, v := range maybeContents.(map[string]interface{}) {`
`252`	`255`	`s, _ := filepath.Split(filepath.Join(outPath, fileName, k))`
`253`	`256`	`if err := os.MkdirAll(s, 0777); err != nil {`
`254`		`- return "", errors.Wrap(err, "write output directories")`
	`257`	`+ return nil, errors.Wrap(err, "write output directories")`
`255`	`258`	`}`
`256`	`259`
`257`	`260`	`decoded, err := base64.StdEncoding.DecodeString(v.(string))`
`258`	`261`	`if err != nil {`
`259`		`- return "", errors.Wrap(err, "decode output")`
	`262`	`+ return nil, errors.Wrap(err, "decode output")`
`260`	`263`	`}`
`261`	`264`	`if err := writeFile(filepath.Join(outPath, fileName, k), decoded); err != nil {`
`262`		`- return "", errors.Wrap(err, "write output")`
	`265`	`+ return nil, errors.Wrap(err, "write output")`
`263`	`266`	`}`
`264`	`267`	`}`
`265`	`268`	`}`
`266`	`269`	`}`
`267`	`270`
`268`		`- return dir, nil`
	`271`	`+ dirs := make([]string, 0)`
	`272`	`+ for dir := range rootDirs {`
	`273`	`+ dirs = append(dirs, dir)`
	`274`	`+ }`
	`275`	`+`
	`276`	`+ return dirs, nil`
`269`	`277`	`}`
`270`	`278`
`271`	`279`	`func uploadSupportBundle(r *troubleshootv1beta1.ResultRequest, archivePath string) error {`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,7 @@ type Logs struct {`
`27`	`27`	CollectorMeta `json:",inline" yaml:",inline"`
`28`	`28`	Selector []string `json:"selector" yaml:"selector"`
`29`	`29`	Namespace string `json:"namespace,omitempty" yaml:"namespace,omitempty"`
	`30`	+ Containers []string `json:"containers,omitempty" yaml:"containers,omitempty"`
`30`	`31`	Limits *LogLimits `json:"limits,omitempty" yaml:"omitempty"`
`31`	`32`	`}`
`32`	`33`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ func runWithoutTimeout(ctx Context, pod corev1.Pod, runCollector *troubleshoot`
`89`	`89`	`limits := troubleshootv1beta1.LogLimits{`
`90`	`90`	`MaxLines: 10000,`
`91`	`91`	`}`
`92`		`- podLogs, err := getPodLogs(client, *pod, &limits, true)`
	`92`	`+ podLogs, err := getPodLogs(client, *pod, "", &limits, true)`
`93`	`93`
`94`	`94`	`for k, v := range podLogs {`
`95`	`95`	`runOutput.PodLogs[k] = v`