| // 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. |
| |
| //go:build linux || darwin |
| // +build linux darwin |
| |
| package main |
| |
| import ( |
| "flag" |
| "fmt" |
| "io/ioutil" |
| "log" |
| "os" |
| osexec "os/exec" |
| "path" |
| "strings" |
| ) |
| |
| // TODO(noahdietz): remove this once the fix in golang.org/x/tools is released. |
| // https://github.com/golang/go/issues/44796 |
| const ignored = "- MaxPublishRequestBytes: value changed from 0.000582077 to 10000000" |
| const rootMod = "cloud.google.com/go" |
| |
| var verbose bool |
| var mod string |
| var base string |
| |
| func init() { |
| flag.StringVar(&mod, "mod", "", "import path of a specific module to diff") |
| flag.BoolVar(&verbose, "verbose", false, "enable verbose command logging") |
| flag.StringVar(&base, "base", "", "path to a copy of google-cloud-go to use as the base") |
| } |
| |
| func main() { |
| flag.Parse() |
| |
| head, err := exec("git", "log", "-2") |
| if err != nil { |
| log.Fatalln(err) |
| } |
| if checkAllowBreakingChange(head) { |
| return |
| } |
| |
| root, err := os.Getwd() |
| if err != nil { |
| log.Fatalln(err) |
| } |
| |
| _, err = exec("go", "install", "golang.org/x/exp/cmd/apidiff@latest") |
| if err != nil { |
| log.Fatalln(err) |
| } |
| |
| if base == "" { |
| temp, err := ioutil.TempDir("/tmp", "google-cloud-go-*") |
| if err != nil { |
| log.Fatalln(err) |
| } |
| defer os.RemoveAll(temp) |
| |
| _, err = exec("git", "clone", "https://github.com/googleapis/google-cloud-go", temp) |
| if err != nil { |
| log.Fatalln(err) |
| } |
| } |
| |
| diffs, diffingErrs, err := diffModules(root, base) |
| if err != nil { |
| log.Fatalln(err) |
| } |
| |
| if len(diffingErrs) > 0 { |
| fmt.Fprintln(os.Stderr, "The following packages encountered errors:") |
| for imp, err := range diffingErrs { |
| fmt.Fprintf(os.Stderr, "%s: %s\n", imp, err) |
| } |
| } |
| |
| if len(diffs) > 0 { |
| fmt.Fprintln(os.Stderr, "The following breaking changes were found:") |
| for imp, d := range diffs { |
| fmt.Fprintf(os.Stderr, "%s:\n%s\n", imp, d) |
| } |
| os.Exit(1) |
| } |
| } |
| |
| func diffModules(root, baseDir string) (map[string]string, map[string]error, error) { |
| diffs := map[string]string{} |
| issues := map[string]error{} |
| |
| m, err := mods() |
| if err != nil { |
| return nil, nil, err |
| } |
| |
| for _, modDir := range m { |
| modPkg := strings.TrimPrefix(modDir, "./") |
| modPkg = strings.TrimSuffix(modPkg, "/go.mod") |
| modImp := rootMod + "/" + modPkg |
| modAbsDir := path.Join(root, modPkg) |
| |
| if mod != "" && modImp != mod { |
| continue |
| } |
| |
| baseModDir := path.Join(baseDir, modPkg) |
| |
| subp, err := subpackages(baseModDir) |
| if err != nil { |
| return nil, nil, err |
| } |
| |
| for _, sub := range subp { |
| if sub == "." { |
| continue |
| } |
| subImp := modImp + strings.TrimPrefix(sub, ".") |
| |
| // Create apidiff base from repo remote HEAD. |
| base, err := writeBase(baseModDir, sub) |
| if err != nil { |
| issues[subImp] = err |
| continue |
| } |
| |
| // Diff the current checked out change against remote HEAD base. |
| out, err := diff(modAbsDir, sub, base) |
| if err != nil { |
| issues[subImp] = err |
| continue |
| } |
| |
| if out != "" && out != ignored { |
| diffs[subImp] = out |
| } |
| } |
| } |
| |
| return diffs, issues, nil |
| } |
| |
| func writeBase(baseModDir, subPkg string) (string, error) { |
| base := path.Join(baseModDir, "pkg.main") |
| _, err := execDir(baseModDir, "apidiff", "-w", base, subPkg) |
| |
| return base, err |
| } |
| |
| func diff(modDir, subpkg, base string) (string, error) { |
| out, err := execDir(modDir, "apidiff", "-allow-internal", "-incompatible", base, subpkg) |
| if err != nil { |
| return "", err |
| } |
| |
| return out, err |
| } |
| |
| func checkAllowBreakingChange(commit string) bool { |
| if strings.Contains(commit, "BREAKING CHANGE:") { |
| log.Println("Not running apidiff because description contained tag BREAKING_CHANGE.") |
| return true |
| } |
| |
| split := strings.Split(commit, "\n") |
| for _, s := range split { |
| if strings.Contains(s, "!:") || strings.Contains(s, "!(") { |
| log.Println("Not running apidiff because description contained breaking change indicator '!'.") |
| return true |
| } |
| } |
| |
| return false |
| } |
| |
| func mods() ([]string, error) { |
| out, err := exec("find", ".", "-name", "go.mod", "-not", "-path", "./internal/*", "-not", "-path", "./go.mod") |
| if err != nil { |
| return nil, err |
| } |
| return strings.Split(out, "\n"), nil |
| } |
| |
| func subpackages(base string) ([]string, error) { |
| out, err := execDir(base, "find", ".", "-mindepth", "1", "-name", "doc.go", "-exec", "dirname", "{}", "\\", ";") |
| if err != nil { |
| return nil, err |
| } |
| return strings.Split(out, "\n"), nil |
| } |
| |
| func execDir(dir, cmd string, args ...string) (string, error) { |
| if verbose { |
| log.Printf("+ %s %s\n", cmd, strings.Join(args, " ")) |
| } |
| c := osexec.Command(cmd, args...) |
| c.Dir = dir |
| out, err := c.CombinedOutput() |
| if err != nil { |
| return "", fmt.Errorf("%s: %w", out, err) |
| } |
| return strings.TrimSpace(string(out)), nil |
| } |
| |
| func exec(cmd string, args ...string) (string, error) { |
| if verbose { |
| log.Printf("+ %s %s\n", cmd, strings.Join(args, " ")) |
| } |
| out, err := osexec.Command(cmd, args...).CombinedOutput() |
| if err != nil { |
| return "", fmt.Errorf("%s: %w", out, err) |
| } |
| return strings.TrimSpace(string(out)), nil |
| } |