Merge pull request #8822 from soltysh/copyright-year

Remove year from copyright header boilerplate

Author: k8s-ci-robot

hack/boilerplate/boilerplate.go.txt

@@ -1,5 +1,5 @@
 /*
-Copyright YEAR The Kubernetes Authors.
+Copyright The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

hack/boilerplate/boilerplate.py

@@ -14,8 +14,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from __future__ import print_function
-
 import argparse
 import datetime
 import difflib
@@ -26,161 +24,159 @@
 
 parser = argparse.ArgumentParser()
 parser.add_argument(
-    "filenames",
-    help="list of files to check, all files if unspecified",
-    nargs='*')
+    "filenames", help="list of files to check, all files if unspecified", nargs="*"
+)
 
 rootdir = os.path.dirname(__file__) + "/../../"
 rootdir = os.path.abspath(rootdir)
-parser.add_argument(
-    "--rootdir", default=rootdir, help="root directory to examine")
+parser.add_argument("--rootdir", default=rootdir, help="root directory to examine")
 
 default_boilerplate_dir = os.path.join(rootdir, "hack/boilerplate")
-parser.add_argument(
-    "--boilerplate-dir", default=default_boilerplate_dir)
+parser.add_argument("--boilerplate-dir", default=default_boilerplate_dir)
 
 parser.add_argument(
-    "-v", "--verbose",
+    "-v",
+    "--verbose",
     help="give verbose output regarding why a file does not pass",
-    action="store_true")
+    action="store_true",
+)
 
 args = parser.parse_args()
 
 verbose_out = sys.stderr if args.verbose else open("/dev/null", "w")
 
+
 def get_refs():
     refs = {}
 
     for path in glob.glob(os.path.join(args.boilerplate_dir, "boilerplate.*.txt")):
         extension = os.path.basename(path).split(".")[1]
 
-        ref_file = open(path, 'r')
-        ref = ref_file.read().splitlines()
-        ref_file.close()
-        refs[extension] = ref
+        with open(path, "r") as ref_file:
+            refs[extension] = ref_file.read().splitlines()
 
     return refs
 
-def is_generated_file(filename, data, regexs):
-    for d in skipped_ungenerated_files:
-        if d in filename:
-            return False
 
-    p = regexs["generated"]
-    return p.search(data)
+def is_generated_file(data, regexs):
+    return regexs["generated"].search(data)
+
 
 def file_passes(filename, refs, regexs):
     try:
-        f = open(filename, 'r')
-    except Exception as exc:
-        print("Unable to open %s: %s" % (filename, exc), file=verbose_out)
+        with open(filename) as stream:
+            data = stream.read()
+    except OSError as exc:
+        print(f"Unable to open {filename}: {exc}", file=verbose_out)
         return False
 
-    data = f.read()
-    f.close()
-
     # determine if the file is automatically generated
-    generated = is_generated_file(filename, data, regexs)
+    generated = is_generated_file(data, regexs)
 
     basename = os.path.basename(filename)
+    extension = file_extension(filename)
     if generated:
-        extension = "generatego"
-    else:
-        extension = file_extension(filename)
+        if extension == "go":
+            extension = "generatego"
 
     if extension != "":
         ref = refs[extension]
     else:
         ref = refs[basename]
 
     # remove extra content from the top of files
-    if extension == "go" or extension == "generatego":
-        p = regexs["go_build_constraints"]
-        (data, found) = p.subn("", data, 1)
-    elif extension == "sh":
-        p = regexs["shebang"]
-        (data, found) = p.subn("", data, 1)
+    if extension in ("go", "generatego"):
+        data, found = regexs["go_build_constraints"].subn("", data, 1)
+    elif extension in ["sh", "py"]:
+        data, found = regexs["shebang"].subn("", data, 1)
 
     data = data.splitlines()
 
     # if our test file is smaller than the reference it surely fails!
     if len(ref) > len(data):
-        print('File %s smaller than reference (%d < %d)' %
-              (filename, len(data), len(ref)),
-              file=verbose_out)
+        print(
+            f"File {filename} smaller than reference ({len(data)} < {len(ref)})",
+            file=verbose_out,
+        )
         return False
 
     # trim our file to the same number of lines as the reference file
-    data = data[:len(ref)]
-
-    p = regexs["year"]
-    for d in data:
-        if p.search(d):
-            if generated:
-                print('File %s has the YEAR field, but it should not be in generated file' % filename, file=verbose_out)
-            else:
-                print('File %s has the YEAR field, but missing the year of date' % filename, file=verbose_out)
-            return False
+    data = data[: len(ref)]
 
     if not generated:
-        # Replace all occurrences of the regex "2014|2015|2016|2017|2018" with "YEAR"
-        p = regexs["date"]
-        for i, d in enumerate(data):
-            (data[i], found) = p.subn('YEAR', d)
+        # Remove all occurrences of the year (regex "Copyright (2014|2015|2016|2017|2018) ")
+        pattern = regexs["date"]
+        for i, line in enumerate(data):
+            data[i], found = pattern.subn("Copyright ", line)
             if found != 0:
                 break
 
     # if we don't match the reference at this point, fail
     if ref != data:
-        print("Header in %s does not match reference, diff:" % filename, file=verbose_out)
+        print(f"Header in {filename} does not match reference, diff:", file=verbose_out)
         if args.verbose:
             print(file=verbose_out)
-            for line in difflib.unified_diff(ref, data, 'reference', filename, lineterm=''):
+            for line in difflib.unified_diff(
+                ref, data, "reference", filename, lineterm=""
+            ):
                 print(line, file=verbose_out)
             print(file=verbose_out)
         return False
 
     return True
 
+
 def file_extension(filename):
     return os.path.splitext(filename)[1].split(".")[-1].lower()
 
-skipped_dirs = ['Godeps', 'third_party', '_gopath', '_output', '.git', 'cluster/env.sh',
-                "vendor", "test/e2e/generated/bindata.go", "hack/boilerplate/test",
-                "pkg/generated/bindata.go",
-                "cluster-autoscaler/expander/grpcplugin/protos",
-                "cluster-autoscaler/cloudprovider/aws/aws-sdk-go",
-                "cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3",
-                "cluster-autoscaler/cloudprovider/bizflycloud/gobizfly",
-                "cluster-autoscaler/cloudprovider/brightbox/gobrightbox",
-                "cluster-autoscaler/cloudprovider/brightbox/k8ssdk",
-                "cluster-autoscaler/cloudprovider/brightbox/linkheader",
-                "cluster-autoscaler/cloudprovider/brightbox/go-cache",
-                "cluster-autoscaler/cloudprovider/digitalocean/godo",
-                "cluster-autoscaler/cloudprovider/externalgrpc/protos",
-                "cluster-autoscaler/cloudprovider/magnum/gophercloud",
-                "cluster-autoscaler/cloudprovider/ionoscloud/ionos-cloud-sdk-go",
-                "cluster-autoscaler/cloudprovider/hetzner/hcloud-go",
-                "cluster-autoscaler/cloudprovider/oci",
-                "cluster-autoscaler/cloudprovider/volcengine/volcengine-go-sdk"]
-
-# list all the files contain 'DO NOT EDIT', but are not generated
-skipped_ungenerated_files = ['hack/build-ui.sh', 'hack/lib/swagger.sh',
-                             'hack/boilerplate/boilerplate.py',
-                             'cluster-autoscaler/cloudprovider/aws/ec2_instance_types/gen.go',
-                             'cluster-autoscaler/cloudprovider/azure/azure_instance_types/gen.go']
+
+skipped_names = [
+    "third_party",
+    "_output",
+    ".git",
+    "cluster/env.sh",
+    "vendor",
+    "testdata",
+    "test/e2e/generated/bindata.go",
+    "hack/boilerplate/test",
+    "hack/boilerplate/boilerplate.py",
+    "hack/scripts/break_mig.py",
+    "hack/scripts/ca_metrics_parser.py",
+    "cluster-autoscaler/update_toc.py",
+    "cluster-autoscaler/hack/list-owners.py",
+    "cluster-autoscaler/expander/grpcplugin/protos",
+    "cluster-autoscaler/cloudprovider/aws/aws-sdk-go",
+    "cluster-autoscaler/cloudprovider/huaweicloud/huaweicloud-sdk-go-v3",
+    "cluster-autoscaler/cloudprovider/bizflycloud/gobizfly",
+    "cluster-autoscaler/cloudprovider/brightbox/gobrightbox",
+    "cluster-autoscaler/cloudprovider/brightbox/k8ssdk",
+    "cluster-autoscaler/cloudprovider/brightbox/linkheader",
+    "cluster-autoscaler/cloudprovider/brightbox/go-cache",
+    "cluster-autoscaler/cloudprovider/digitalocean/godo",
+    "cluster-autoscaler/cloudprovider/externalgrpc/protos",
+    "cluster-autoscaler/cloudprovider/magnum/gophercloud",
+    "cluster-autoscaler/cloudprovider/ionoscloud/ionos-cloud-sdk-go",
+    "cluster-autoscaler/cloudprovider/hetzner/hcloud-go",
+    "cluster-autoscaler/cloudprovider/oci",
+    "cluster-autoscaler/cloudprovider/volcengine/volcengine-go-sdk",
+    "cluster-autoscaler/cloudprovider/aws/ec2_instance_types/gen.go",
+    "cluster-autoscaler/cloudprovider/azure/azure_instance_types/gen.go",
+    "vertical-pod-autoscaler/hack/emit-metrics.py",
+]
+
 
 def normalize_files(files):
     newfiles = []
     for pathname in files:
-        if any(x in pathname for x in skipped_dirs):
+        if any(x in pathname for x in skipped_names):
             continue
         newfiles.append(pathname)
     for i, pathname in enumerate(newfiles):
         if not os.path.isabs(pathname):
             newfiles[i] = os.path.join(args.rootdir, pathname)
     return newfiles
 
+
 def get_files(extensions):
     files = []
     if len(args.filenames) > 0:
@@ -191,9 +187,13 @@ def get_files(extensions):
             # as we would prune these later in normalize_files(). But doing it
             # cuts down the amount of filesystem walking we do and cuts down
             # the size of the file list
-            for d in skipped_dirs:
-                if d in dirs:
-                    dirs.remove(d)
+            for dname in skipped_names:
+                if dname in dirs:
+                    dirs.remove(dname)
+            for dname in dirs:
+                # dirs that start with __ are ignored
+                if dname.startswith("__"):
+                    dirs.remove(dname)
 
             for name in walkfiles:
                 pathname = os.path.join(root, name)
@@ -208,39 +208,44 @@ def get_files(extensions):
             outfiles.append(pathname)
     return outfiles
 
+
 def get_dates():
-    years = datetime.datetime.now().year
-    return '(%s)' % '|'.join((str(year) for year in range(2014, years+1)))
+    # After 2025, we no longer allow new files to include the year in the copyright header.
+    final_year = 2025
+    return " (%s) " % "|".join(str(year) for year in range(2014, final_year + 1))
+
 
 def get_regexs():
     regexs = {}
     # Search for "YEAR" which exists in the boilerplate, but shouldn't in the real thing
-    regexs["year"] = re.compile( 'YEAR' )
-    # get_dates return 2014, 2015, 2016, 2017, or 2018 until the current year as a regex like: "(2014|2015|2016|2017|2018)";
-    # company holder names can be anything
-    regexs["date"] = re.compile(get_dates())
-    # strip // +build \n\n build constraints
+    regexs["year"] = re.compile("YEAR")
+    # get_dates return 2014, 2015, 2016, 2017, ..., 2025
+    # as a regex like: "(2014|2015|2016|2017|2018|...|2025)";
+    regexs["date"] = re.compile("Copyright" + get_dates())
+    # strip the following build constraints/tags:
+    # //go:build
+    # // +build \n\n
     regexs["go_build_constraints"] = re.compile(
-        r"^(//(go:build| \+build).*\n)+\n", re.MULTILINE)
-    # strip #!.* from shell scripts
+        r"^(//(go:build| \+build).*\n)+\n", re.MULTILINE
+    )
+    # strip #!.* from scripts
     regexs["shebang"] = re.compile(r"^(#!.*\n)\n*", re.MULTILINE)
     # Search for generated files
-    regexs["generated"] = re.compile( 'DO NOT EDIT' )
+    regexs["generated"] = re.compile(r"^[/*#]+ +.* DO NOT EDIT\.$", re.MULTILINE)
     return regexs
 
+
 def main():
     regexs = get_regexs()
     refs = get_refs()
-    filenames = get_files(refs.keys())
+    filenames = get_files(refs)
 
     for filename in filenames:
-      if "/cluster-autoscaler/_override/" in filename:
-            continue
-
-      if not file_passes(filename, refs, regexs):
-            print(filename, file=sys.stdout)
+        if not file_passes(filename, refs, regexs):
+            print(filename)
 
     return 0
 
+
 if __name__ == "__main__":
-  sys.exit(main())
+    sys.exit(main())

hack/boilerplate/boilerplate.py.txt

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 
-# Copyright YEAR The Kubernetes Authors.
+# Copyright The Kubernetes Authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

hack/boilerplate/boilerplate.sh.txt

@@ -1,4 +1,4 @@
-# Copyright YEAR The Kubernetes Authors.
+# Copyright The Kubernetes Authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

hack/verify-boilerplate.sh

@@ -23,12 +23,15 @@ KUBE_ROOT=$(dirname "${BASH_SOURCE}")/..
 boilerDir="${KUBE_ROOT}/hack/boilerplate"
 boiler="${boilerDir}/boilerplate.py"
 
-files_need_boilerplate=($(${boiler} "$@"))
+files_need_boilerplate=()
+while IFS=$'\n' read -r line; do
+  files_need_boilerplate+=( "$line" )
+done < <("${boiler}" "$@")
 
 # Run boilerplate check
 if [[ ${#files_need_boilerplate[@]} -gt 0 ]]; then
   for file in "${files_need_boilerplate[@]}"; do
-    echo "Boilerplate header is wrong for: ${file}"
+    echo "Boilerplate header is wrong for: ${file}" >&2
   done
 
   exit 1