Improve output

Signed-off-by: David Gageot <[email protected]>

Author: dgageot

cmd/skaffold/app/cmd/diagnose.go

@@ -22,6 +22,7 @@ import (
 	"io/ioutil"
 	"time"
 
+	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/color"
 	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/docker"
 	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/runner"
 	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/schema/latest"
@@ -56,55 +57,75 @@ func doDiagnose(out io.Writer) error {
 	fmt.Fprintln(out, "Configuration version:", config.APIVersion)
 	fmt.Fprintln(out, "Number of artifacts:", len(config.Build.Artifacts))
 
-	fmt.Fprintln(out, "\nRunning a diagnostic on artifacts and their dependencies:")
-
 	if err := diagnoseArtifacts(out, config.Build.Artifacts); err != nil {
 		return errors.Wrap(err, "running diagnostic on artifacts")
 	}
 
-	fmt.Fprintln(out, "\nSecond run (that benefits from cache):")
-
-	if err := diagnoseArtifacts(out, config.Build.Artifacts); err != nil {
-		return errors.Wrap(err, "running second diagnostic on artifacts")
-	}
-
 	return nil
 }
 
 func diagnoseArtifacts(out io.Writer, artifacts []*latest.Artifact) error {
 	for _, artifact := range artifacts {
-		start := time.Now()
-		deps, err := runner.DependenciesForArtifact(artifact)
-		if err != nil {
-			return errors.Wrap(err, "listing artifact dependencies")
-		}
-
-		fmt.Fprintln(out, "Type:", typeOfArtifact(artifact))
-		fmt.Fprintln(out, " - Dependencies to watch:", len(deps))
-		fmt.Fprintln(out, " - Time to list dependencies:", time.Since(start))
+		color.Default.Fprintf(out, "\n%s: %s\n", typeOfArtifact(artifact), artifact.ImageName)
 
 		if artifact.DockerArtifact != nil {
-			size, err := sizeOfTheDockerContext(artifact)
+			size, err := sizeOfDockerContext(artifact)
 			if err != nil {
 				return errors.Wrap(err, "computing the size of the Docker context")
 			}
 
-			fmt.Fprintln(out, " - Size of the Docker context:", size)
+			fmt.Fprintf(out, " - Size of the context: %vbytes\n", size)
 		}
 
-		start = time.Now()
-		_, err = watch.Stat(func() ([]string, error) { return deps, nil })
+		timeDeps1, deps, err := timeToListDependencies(artifact)
+		if err != nil {
+			return errors.Wrap(err, "listing artifact dependencies")
+		}
+		timeDeps2, _, err := timeToListDependencies(artifact)
+		if err != nil {
+			return errors.Wrap(err, "listing artifact dependencies")
+		}
+
+		fmt.Fprintln(out, " - Dependencies:", len(deps), "files")
+		fmt.Fprintf(out, " - Time to list dependencies: %v (2nd time: %v)\n", timeDeps1, timeDeps2)
+
+		timeMTimes1, err := timeToComputeMTimes(deps)
+		if err != nil {
+			return errors.Wrap(err, "computing modTimes")
+		}
+		timeMTimes2, err := timeToComputeMTimes(deps)
 		if err != nil {
 			return errors.Wrap(err, "computing modTimes")
 		}
 
-		fmt.Fprintln(out, " - Time to compute mTimes for all dependencies:", time.Since(start))
+		fmt.Fprintf(out, " - Time to compute mTimes on dependencies: %v (2nd time: %v)\n", timeMTimes1, timeMTimes2)
 	}
 
 	return nil
 }
 
-func sizeOfTheDockerContext(a *latest.Artifact) (int64, error) {
+func timeToListDependencies(a *latest.Artifact) (time.Duration, []string, error) {
+	start := time.Now()
+
+	deps, err := runner.DependenciesForArtifact(a)
+	if err != nil {
+		return 0, nil, errors.Wrap(err, "listing artifact dependencies")
+	}
+
+	return time.Since(start), deps, nil
+}
+
+func timeToComputeMTimes(deps []string) (time.Duration, error) {
+	start := time.Now()
+
+	if _, err := watch.Stat(func() ([]string, error) { return deps, nil }); err != nil {
+		return 0, errors.Wrap(err, "computing modTimes")
+	}
+
+	return time.Since(start), nil
+}
+
+func sizeOfDockerContext(a *latest.Artifact) (int64, error) {
 	buildCtx, buildCtxWriter := io.Pipe()
 	go func() {
 		err := docker.CreateDockerTarContext(buildCtxWriter, a.Workspace, a.DockerArtifact)
@@ -121,10 +142,10 @@ func sizeOfTheDockerContext(a *latest.Artifact) (int64, error) {
 func typeOfArtifact(a *latest.Artifact) string {
 	switch {
 	case a.DockerArtifact != nil:
-		return "Docker"
+		return "Docker artifact"
 	case a.BazelArtifact != nil:
-		return "Bazel"
+		return "Bazel artifact"
 	default:
-		return "Unknown"
+		return "Unknown artifact"
 	}
 }