cmd/vulnreport: add subcommand framework

Adds a new unified framework for vulnreport subcommands. Each subcommand
now implements an interface, command, which has functions for setting up,
running, and tearing down the command.

Change-Id: I7c6ab5cf1b4c19b300dbdef6df0d76e2f1f303ea
Reviewed-on: https://go-review.googlesource.com/c/vulndb/+/559955
Reviewed-by: Damien Neil <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: tatianab

cmd/vulnreport/command.go

@@ -0,0 +1,94 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"golang.org/x/vulndb/cmd/vulnreport/log"
+)
+
+// command represents a subcommand of vulnreport.
+type command interface {
+	// name outputs the string used to invoke the subcommand.
+	name() string
+	// usage outputs strings indicating how to use the subcommand.
+	usage() (args string, desc string)
+	// setup populates any state needed to run the subcommand.
+	setup(context.Context) error
+	// parseArgs takes in the raw args passed to the command line,
+	// and converts them to a representation understood by "run".
+	// This function need not be one-to-one: there may be more
+	// inputs than args or vice-versa.
+	parseArgs(_ context.Context, args []string) (inputs []string, _ error)
+	// run executes the subcommand on the given input.
+	run(_ context.Context, input string) error
+	// close cleans up state and/or completes tasks that should occur
+	// after run is called on all inputs.
+	close() error
+}
+
+// run executes the given command on the given raw arguments.
+func run(ctx context.Context, c command, args []string) error {
+	if err := c.setup(ctx); err != nil {
+		return err
+	}
+	defer c.close()
+
+	inputs, err := c.parseArgs(ctx, args)
+	if err != nil {
+		return err
+	}
+
+	for _, input := range inputs {
+		log.Infof("%s %v", c.name(), input)
+		if err := c.run(ctx, input); err != nil {
+			log.Errf("%s: %s", c.name(), err)
+		}
+	}
+	return nil
+}
+
+const (
+	filenameArgs = "[filename | github-id] ..."
+	ghIssueArgs  = "[github-id] ..."
+)
+
+// filenameParser implements the "parseArgs" function of the command
+// interface, and can be used by commands that operate on YAML filenames.
+type filenameParser bool
+
+func (filenameParser) parseArgs(_ context.Context, args []string) (filenames []string, _ error) {
+	if len(args) == 0 {
+		return nil, fmt.Errorf("no arguments provided")
+	}
+	for _, arg := range args {
+		fname, err := argToFilename(arg)
+		if err != nil {
+			log.Err(err)
+			continue
+		}
+		filenames = append(filenames, fname)
+	}
+	return filenames, nil
+}
+
+func argToFilename(arg string) (string, error) {
+	if _, err := os.Stat(arg); err != nil {
+		// If arg isn't a file, see if it might be an issue ID
+		// with an existing report.
+		for _, padding := range []string{"", "0", "00", "000"} {
+			m, _ := filepath.Glob("data/*/GO-*-" + padding + arg + ".yaml")
+			if len(m) == 1 {
+				return m[0], nil
+			}
+		}
+		return "", fmt.Errorf("%s is not a valid filename or issue ID with existing report: %w", arg, err)
+	}
+	return arg, nil
+}

cmd/vulnreport/commit.go

@@ -11,7 +11,6 @@ import (
 	"strings"
 
 	"golang.org/x/exp/slices"
-	"golang.org/x/vulndb/internal/derrors"
 	"golang.org/x/vulndb/internal/ghsa"
 	"golang.org/x/vulndb/internal/proxy"
 	"golang.org/x/vulndb/internal/report"
@@ -21,16 +20,36 @@ var (
 	updateIssue = flag.Bool("up", false, "for commit, create a CL that updates (doesn't fix) the tracking bug")
 )
 
-func commit(ctx context.Context, filename string, ghsaClient *ghsa.Client, pc *proxy.Client, force bool) (err error) {
-	defer derrors.Wrap(&err, "commit(%q)", filename)
+type commit struct {
+	pc *proxy.Client
+	gc *ghsa.Client
 
+	filenameParser
+}
+
+func (commit) name() string { return "commit" }
+
+func (commit) usage() (string, string) {
+	const desc = "creates new commits for YAML reports"
+	return filenameArgs, desc
+}
+
+func (c *commit) setup(ctx context.Context) error {
+	c.pc = proxy.NewDefaultClient()
+	c.gc = ghsa.NewClient(ctx, *githubToken)
+	return nil
+}
+
+func (c *commit) close() error { return nil }
+
+func (c *commit) run(ctx context.Context, filename string) (err error) {
 	// Clean up the report file and lint the result.
 	// Stop if there any problems.
-	if err := fix(ctx, filename, ghsaClient, pc, force); err != nil {
+	r, err := report.ReadAndLint(filename, c.pc)
+	if err != nil {
 		return err
 	}
-	r, err := report.ReadAndLint(filename, pc)
-	if err != nil {
+	if err := fixReport(ctx, r, filename, c.pc, c.gc); err != nil {
 		return err
 	}
 	if hasUnaddressedTodos(r) {