add graph analysis

Author: juanvallejo

tools/depcheck/pkg/analyze/analyze.go

@@ -0,0 +1,14 @@
+package analyze
+
+import (
+	"github.com/openshift/origin/tools/depcheck/pkg/graph"
+)
+
+func FindExclusiveDependencies(g *graph.MutableDirectedGraph, targetNodes []*graph.Node) []*graph.Node {
+	newGraph := g.Copy()
+	for _, target := range targetNodes {
+		newGraph.RemoveNode(target)
+	}
+
+	return newGraph.PruneOrphans()
+}

tools/depcheck/pkg/cmd/analyze.go

@@ -0,0 +1,211 @@
+package cmd
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/gonum/graph/path"
+
+	"github.com/openshift/origin/tools/depcheck/pkg/analyze"
+	"github.com/openshift/origin/tools/depcheck/pkg/graph"
+)
+
+var analyzeImportsExample = `# analyze a dependency graph against one of its vendor packages
+%[1]s analyze --root=github.com/openshift/origin --entry=pkg/foo/... --dep=github.com/openshift/origin/vendor/k8s.io/kubernetes
+`
+
+type AnalyzeOptions struct {
+	*graph.GraphOptions
+
+	// Packages to analyze against
+	Dependencies []string
+
+	Out    io.Writer
+	ErrOut io.Writer
+}
+
+type AnalyzeFlags struct {
+	*graph.GraphFlags
+
+	Dependencies []string
+}
+
+func (o *AnalyzeFlags) ToOptions(out, errout io.Writer) (*AnalyzeOptions, error) {
+	graphOpts, err := o.GraphFlags.ToOptions(out, errout)
+	if err != nil {
+		return nil, err
+	}
+
+	return &AnalyzeOptions{
+		GraphOptions: graphOpts,
+		Dependencies: o.Dependencies,
+
+		Out:    out,
+		ErrOut: errout,
+	}, nil
+}
+
+func NewCmdAnalyzeImports(parent string, out, errout io.Writer) *cobra.Command {
+	analyzeFlags := &AnalyzeFlags{
+		GraphFlags: &graph.GraphFlags{},
+	}
+
+	cmd := &cobra.Command{
+		Use:     "analyze --root=github.com/openshift/origin --entry=pkg/foo/... --dep pkg/vendor/bar",
+		Short:   "Creates and analyzes a dependency graph against a specified subpackage",
+		Long:    "Creates and analyzes a dependency graph against a specified subpackage",
+		Example: fmt.Sprintf(traceImportsExample, parent),
+		RunE: func(c *cobra.Command, args []string) error {
+			opts, err := analyzeFlags.ToOptions(out, errout)
+			if err != nil {
+				return err
+			}
+
+			if err := opts.Complete(); err != nil {
+				return err
+			}
+			if err := opts.Validate(); err != nil {
+				return err
+			}
+			if err := opts.Run(); err != nil {
+				return err
+			}
+
+			return nil
+		},
+	}
+
+	analyzeFlags.AddFlags(cmd)
+	cmd.Flags().StringSliceVarP(&analyzeFlags.Dependencies, "dep", "d", analyzeFlags.Dependencies, "set of dependencies to calculate \"yours\" dependencies against, in a summary report on the dependency sets of a given repository.")
+	return cmd
+}
+
+func (o *AnalyzeOptions) Complete() error {
+	return o.GraphOptions.Complete()
+}
+
+func (o *AnalyzeOptions) Validate() error {
+	if err := o.GraphOptions.Validate(); err != nil {
+		return err
+	}
+	if len(o.Dependencies) == 0 {
+		return errors.New("at least one --dep package must be specified")
+	}
+
+	return nil
+}
+
+func (o *AnalyzeOptions) Run() error {
+	g, err := o.GraphOptions.BuildGraph()
+	if err != nil {
+		return err
+	}
+
+	return o.analyzeGraph(g)
+}
+
+// analyzeGraph receives a MutableDirectedGraph and outputs
+// - "Yours": a list of every node in the set unique to the dependency tree of a given target node.
+// - "Mine": a list of every node in the set unique to the dependency tree of the root nodes (set non-overlapping with given target node)
+// - "Ours": a list of every node in the overlapping set between the dependency tree of the root nodes and a given target node
+func (o *AnalyzeOptions) analyzeGraph(g *graph.MutableDirectedGraph) error {
+	yoursRoots := []*graph.Node{}
+	for _, dep := range o.Dependencies {
+		n, exists := g.NodeByName(dep)
+		if !exists {
+			return fmt.Errorf("unable to find dependency with import path %q", dep)
+		}
+		node, ok := n.(*graph.Node)
+		if !ok {
+			return fmt.Errorf("expected node to analyze to be of type *graph.Node. Got: %v", n)
+		}
+
+		yoursRoots = append(yoursRoots, node)
+	}
+
+	fmt.Printf("Analyzing a total of %v packages\n", len(g.Nodes()))
+	fmt.Println()
+
+	yours := analyze.FindExclusiveDependencies(g, yoursRoots)
+	fmt.Printf("\"Yours\": %v dependencies exclusive to %q\n", len(yours), yoursRoots)
+	for _, n := range yours {
+		fmt.Printf("    - %s\n", n)
+	}
+	fmt.Println()
+
+	// calculate root repo packages, as well as their
+	// immediate vendor package dependencies
+	unfilteredMine := map[int]*graph.Node{}
+	for _, n := range g.Nodes() {
+		node, ok := n.(*graph.Node)
+		if !ok {
+			return fmt.Errorf("expected node to analyze to be of type *graph.Node. Got: %v", n)
+		}
+		if isVendorPackage(node) {
+			continue
+		}
+
+		// obtain immediate vendor package deps from the current node
+		// and aggregate those as well
+		for _, v := range g.From(n) {
+			if !isVendorPackage(v.(*graph.Node)) {
+				continue
+			}
+
+			unfilteredMine[v.ID()] = v.(*graph.Node)
+		}
+	}
+
+	mine := []*graph.Node{}
+	ours := []*graph.Node{}
+	for _, n := range unfilteredMine {
+		// determine if the current origin node is reachable from any of the "yours" packages
+		if isReachableFrom(g, yours, n) {
+			ours = append(ours, n)
+			continue
+		}
+
+		mine = append(mine, n)
+	}
+
+	fmt.Printf("\"Mine\": %v direct (first-level) dependencies exclusive to the origin repo\n", len(mine))
+	for _, n := range mine {
+		fmt.Printf("    - %s\n", n)
+	}
+	fmt.Println()
+
+	fmt.Printf("\"Ours\": %v shared dependencies between the origin repo and %v\n", len(ours), yoursRoots)
+	for _, n := range ours {
+		fmt.Printf("    - %s\n", n)
+	}
+
+	return nil
+}
+
+// isVendorPackage receives a *graph.Node and
+// returns true if the given node's unique name is in the vendor path.
+func isVendorPackage(n *graph.Node) bool {
+	if strings.Contains(n.UniqueName, "/vendor/") {
+		return true
+	}
+
+	return false
+}
+
+// isReachableFrom receives a set of root nodes and determines
+// if a given destination node can be reached from any of them.
+func isReachableFrom(g *graph.MutableDirectedGraph, roots []*graph.Node, dest *graph.Node) bool {
+	for _, root := range roots {
+		// no negative edge weights, use Dijkstra
+		paths := path.DijkstraFrom(root, g)
+		if pathTo, _ := paths.To(dest); len(pathTo) > 0 {
+			return true
+		}
+	}
+
+	return false
+}

tools/depcheck/pkg/cmd/cmd.go

@@ -23,6 +23,7 @@ func NewCmdDepCheck(name string, out, errout io.Writer) *cobra.Command {
 
 	cmd.AddCommand(NewCmdPinImports(name, out, errout))
 	cmd.AddCommand(NewCmdTraceImports(name, out, errout))
+	cmd.AddCommand(NewCmdAnalyzeImports(name, out, errout))
 
 	// add glog flags to our global flag set
 	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)