blob: 318cd918e62b382a33b87d03698b9765ca9dd632 [file] [log] [blame]
// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package main
import (
"compliance"
"flag"
"fmt"
"io"
"os"
"path/filepath"
"sort"
"strings"
)
var (
conditions = newMultiString("c", "License condition to resolve. (may be given multiple times)")
graphViz = flag.Bool("dot", false, "Whether to output graphviz (i.e. dot) format.")
labelConditions = flag.Bool("label_conditions", false, "Whether to label target nodes with conditions.")
stripPrefix = flag.String("strip_prefix", "", "Prefix to remove from paths. i.e. path to root")
failNoneRequested = fmt.Errorf("\nNo license metadata files requested")
failNoLicenses = fmt.Errorf("No licenses found")
)
type context struct {
conditions []compliance.LicenseCondition
graphViz bool
labelConditions bool
stripPrefix string
}
func init() {
flag.Usage = func() {
fmt.Fprintf(os.Stderr, `Usage: %s {options} file.meta_lic {file.meta_lic...}
Outputs a space-separated Target ActsOn Origin Condition tuple for each
resolution in the graph. When -dot flag given, outputs nodes and edges
in graphviz directed graph format.
If one or more '-c condition' conditions are given, outputs the
resolution for the union of the conditions. Otherwise, outputs the
resolution for all conditions.
In plain text mode, when '-label_conditions' is requested, the Target
and Origin have colon-separated license conditions appended:
i.e. target:condition1:condition2 etc.
Options:
`, filepath.Base(os.Args[0]))
flag.PrintDefaults()
}
}
// newMultiString creates a flag that allows multiple values in an array.
func newMultiString(name, usage string) *multiString {
var f multiString
flag.Var(&f, name, usage)
return &f
}
// multiString implements the flag `Value` interface for multiple strings.
type multiString []string
func (ms *multiString) String() string { return strings.Join(*ms, ", ") }
func (ms *multiString) Set(s string) error { *ms = append(*ms, s); return nil }
func main() {
flag.Parse()
// Must specify at least one root target.
if flag.NArg() == 0 {
flag.Usage()
os.Exit(2)
}
lcs := make([]compliance.LicenseCondition, 0, len(*conditions))
for _, name := range *conditions {
lcs = append(lcs, compliance.RecognizedConditionNames[name])
}
ctx := &context{
conditions: lcs,
graphViz: *graphViz,
labelConditions: *labelConditions,
stripPrefix: *stripPrefix,
}
_, err := dumpResolutions(ctx, os.Stdout, os.Stderr, flag.Args()...)
if err != nil {
if err == failNoneRequested {
flag.Usage()
}
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
os.Exit(1)
}
os.Exit(0)
}
// dumpResolutions implements the dumpresolutions utility.
func dumpResolutions(ctx *context, stdout, stderr io.Writer, files ...string) (*compliance.LicenseGraph, error) {
if len(files) < 1 {
return nil, failNoneRequested
}
// Read the license graph from the license metadata files (*.meta_lic).
licenseGraph, err := compliance.ReadLicenseGraph(os.DirFS("."), stderr, files)
if err != nil {
return nil, fmt.Errorf("Unable to read license metadata file(s) %q: %v\n", files, err)
}
if licenseGraph == nil {
return nil, failNoLicenses
}
compliance.ResolveTopDownConditions(licenseGraph)
cs := compliance.AllLicenseConditions
if len(ctx.conditions) > 0 {
cs = compliance.NewLicenseConditionSet()
for _, c := range ctx.conditions {
cs = cs.Plus(c)
}
}
resolutions := compliance.WalkResolutionsForCondition(licenseGraph, cs)
// nodes maps license metadata file names to graphViz node names when graphViz requested.
nodes := make(map[string]string)
n := 0
// targetOut calculates the string to output for `target` adding `sep`-separated conditions as needed.
targetOut := func(target *compliance.TargetNode, sep string) string {
tOut := strings.TrimPrefix(target.Name(), ctx.stripPrefix)
if ctx.labelConditions {
conditions := target.LicenseConditions().Names()
if len(conditions) > 0 {
tOut += sep + strings.Join(conditions, sep)
}
}
return tOut
}
// makeNode maps `target` to a graphViz node name.
makeNode := func(target *compliance.TargetNode) {
tName := target.Name()
if _, ok := nodes[tName]; !ok {
nodeName := fmt.Sprintf("n%d", n)
nodes[tName] = nodeName
fmt.Fprintf(stdout, "\t%s [label=\"%s\"];\n", nodeName, targetOut(target, "\\n"))
n++
}
}
// outputResolution prints a resolution in the requested format to `stdout`, where one can read
// a resolution as `tname` resolves `oname`'s conditions named in `cnames`.
// `tname` is the name of the target the resolution applies to.
// `cnames` is the list of conditions to resolve.
outputResolution := func(tname, aname string, cnames []string) {
if ctx.graphViz {
// ... one edge per line labelled with \\n-separated annotations.
tNode := nodes[tname]
aNode := nodes[aname]
fmt.Fprintf(stdout, "\t%s -> %s [label=\"%s\"];\n", tNode, aNode, strings.Join(cnames, "\\n"))
} else {
// ... one edge per line with names in a colon-separated tuple.
fmt.Fprintf(stdout, "%s %s %s\n", tname, aname, strings.Join(cnames, ":"))
}
}
// Sort the resolutions by targetname for repeatability/stability.
targets := resolutions.AttachesTo()
sort.Sort(targets)
// If graphviz output, start the directed graph.
if ctx.graphViz {
fmt.Fprintf(stdout, "strict digraph {\n\trankdir=LR;\n")
for _, target := range targets {
makeNode(target)
rl := resolutions.Resolutions(target)
sort.Sort(rl)
for _, r := range rl {
makeNode(r.ActsOn())
}
}
}
// Output the sorted targets.
for _, target := range targets {
var tname string
if ctx.graphViz {
tname = target.Name()
} else {
tname = targetOut(target, ":")
}
rl := resolutions.Resolutions(target)
sort.Sort(rl)
for _, r := range rl {
var aname string
if ctx.graphViz {
aname = r.ActsOn().Name()
} else {
aname = targetOut(r.ActsOn(), ":")
}
// cnames accumulates the list of condition names originating at a single origin that apply to `target`.
cnames := r.Resolves().Names()
// Output 1 line for each attachesTo+actsOn combination.
outputResolution(tname, aname, cnames)
}
}
// If graphViz output, rank the root nodes together, and complete the directed graph.
if ctx.graphViz {
fmt.Fprintf(stdout, "\t{rank=same;")
for _, f := range files {
fName := f
if !strings.HasSuffix(fName, ".meta_lic") {
fName += ".meta_lic"
}
if fNode, ok := nodes[fName]; ok {
fmt.Fprintf(stdout, " %s", fNode)
}
}
fmt.Fprintf(stdout, "}\n}\n")
}
return licenseGraph, nil
}