[Android WebView] Make 3rd party licenses checker to turn bot red

android_webview/tools/webview_licenses.py

 #!/usr/bin/python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Checks third-party licenses for the purposes of the Android WebView build.
 
 The Android tree includes a snapshot of Chromium in order to power the system
 WebView.  This tool checks that all code uses open-source licenses compatible
 with Android, and that we meet the requirements of those licenses. It can also
@@ skipping 56 matching lines @@
     if metadata.get('License Android Compatible', 'no') == 'yes':
       continue
     license = re.split(' [Ll]icenses?$', metadata['License'])[0]
     tokens = [x.strip() for x in re.split(' and |,', license) if len(x) > 0]
     for token in tokens:
       if not re.match(regex, token, re.IGNORECASE):
         result.append(directory)
         break
   return result
 
+SCAN_OK = 0
+SCAN_WARNINGS = 1 << 0
+SCAN_ERRORS = 1 << 1

[mkosiba (inactive), 2013/02/06 15:40:49]

It seems these are exclusive, not flags, so how about:

  class ScanResult: # or ScanStatus
      Ok, Warnings, Errors = range(3) # or [0] + [1 << i for i in range(2)]

Based on
http://stackoverflow.com/questions/702834/whats-the-common-practice-for-enums...

[mnaganov (inactive), 2013/02/06 16:42:17]

Fixed, thanks!

 
 def _CheckLicenseHeaders(excluded_dirs_list, whitelisted_files):
   """Checks that all files which are not in a listed third-party directory,
   and which do not use the standard Chromium license, are whitelisted.
   Args:
     excluded_dirs_list: The list of directories to exclude from scanning.
     whitelisted_files: The whitelist of files.
   Returns:
-    True if all files with non-standard license headers are whitelisted and the
-    whitelist contains no stale entries, otherwise false.
+    SCAN_OK if all files with non-standard license headers are whitelisted and

[mkosiba (inactive), 2013/02/06 15:40:49]

if you go with the suggestion above you could say Returns: ScanResult and move
the documentation to the ScanResult class (and then you wouldn't need to repeat
all of the status code descriptions in every function)

[mnaganov (inactive), 2013/02/06 16:42:17]

The interpretation of results are method-dependent. _CheckLicenseHeaders only
deals with non-third party code copyrights status, while _Scan also deals with
third-party code licensing metadata. I think it's worth to have explicit
descriptions.

[mkosiba (inactive), 2013/02/06 16:54:51]

ah, ok then.

+    the whitelist contains no stale entries;
+    SCAN_WARNINGS if there are stale entries;
+    SCAN_ERRORS if new non-whitelisted entries found.
   """
 
   excluded_dirs_list = [d for d in excluded_dirs_list if not 'third_party' in d]
   # Using a commond pattern for third-partyies makes the ignore regexp shorter
   excluded_dirs_list.append('third_party')
   # VCS dirs
   excluded_dirs_list.append('.git')
   excluded_dirs_list.append('.svn')
   # Build output
   excluded_dirs_list.append('out/Debug')
@@ skipping 25 matching lines @@
   for l in lines:
     entries = l.split('\t')
     if entries[1] == "GENERATED FILE":
       continue
     copyrights = entries[1].split(' / ')
     for c in copyrights:
       if c and not allowed_copyrights_re.match(c):
         offending_files.append(os.path.normpath(entries[0]))
         break
 
-  all_files_valid = True
   unknown = set(offending_files) - set(whitelisted_files)
   if unknown:
     print 'The following files contain a third-party license but are not in ' \
           'a listed third-party directory and are not whitelisted. You must ' \
           'add the following files to the whitelist.\n%s' % \
           '\n'.join(sorted(unknown))
-    all_files_valid = False
 
   stale = set(whitelisted_files) - set(offending_files)
   if stale:
     print 'The following files are whitelisted unnecessarily. You must ' \
           ' remove the following files from the whitelist.\n%s' % \
           '\n'.join(sorted(stale))
-    all_files_valid = False
 
-  return all_files_valid
+  return SCAN_ERRORS if unknown else (SCAN_WARNINGS if stale else SCAN_OK)

[mkosiba (inactive), 2013/02/06 15:40:49]

I think it would be slightly clearer to make this an old-fashioned if/elif:

if unknown:
    return SCAN_ERRORS
elif stale:
    return SCAN_WARNINGS
else:
    return SCAN_OK

[mnaganov (inactive), 2013/02/06 16:42:17]

Done.

 
 
 def _ReadFile(path):
   """Reads a file from disk.
   Args:
     path: The path of the file to read, relative to the root of the repository.
   Returns:
     The contents of the file as a string.
   """
 
@@ skipping 20 matching lines @@
     # The llvm-build doesn't exist for non-clang builder
     os.path.join('third_party', 'llvm-build'),
     # Binaries doesn't apply to android
     os.path.join('third_party', 'widevine'),
   ]
   third_party_dirs = licenses.FindThirdPartyDirs(prune_paths, REPOSITORY_ROOT)
   return licenses.FilterDirsWithFiles(third_party_dirs, REPOSITORY_ROOT)
 
 
 def _Scan():
-  """Checks that license meta-data is present for all third-party code.
+  """Checks that license meta-data is present for all third-party code and
+     that all non third-party code doesn't contain external copyrighted code.
   Returns:
-    Whether the check succeeded.
+    SCAN_OK if everything is in order;
+    SCAN_WARNINGS if there are non-fatal problems (e.g. stale whitelist entries)
+    SCAN_ERRORS otherwise.
   """
 
   third_party_dirs = _FindThirdPartyDirs()
 
   # First, check designated third-party directories using src/tools/licenses.py.
   all_licenses_valid = True
   for path in sorted(third_party_dirs):
     try:
       licenses.ParseDir(path, REPOSITORY_ROOT)
     except licenses.LicenseError, e:
       if not (path in known_issues.KNOWN_ISSUES):
         print 'Got LicenseError "%s" while scanning %s' % (e, path)
         all_licenses_valid = False
 
   # Second, check for non-standard license text.
   files_data = _ReadFile(os.path.join('android_webview', 'tools',
                                       'third_party_files_whitelist.txt'))
   whitelisted_files = []
   for line in files_data.splitlines():
     match = re.match(r'([^#\s]+)', line)
     if match:
       whitelisted_files.append(match.group(1))
-  return _CheckLicenseHeaders(third_party_dirs, whitelisted_files) \
-      and all_licenses_valid
+  licenses_check = _CheckLicenseHeaders(third_party_dirs, whitelisted_files)
+
+  return licenses_check if all_licenses_valid else SCAN_ERRORS
 
 
 def GenerateNoticeFile():
   """Generates the contents of an Android NOTICE file for the third-party code.
   This is used by the snapshot tool.
   Returns:
     The contents of the NOTICE file.
   """
 
   third_party_dirs = _FindThirdPartyDirs()
@@ skipping 22 matching lines @@
 
   parser = optparse.OptionParser(formatter=FormatterWithNewLines(),
                                  usage='%prog [options]')
   parser.description = (__doc__ +
                        '\nCommands:\n' \
                        '  scan  Check licenses.\n' \
                        '  notice Generate Android NOTICE file on stdout')
   (options, args) = parser.parse_args()
   if len(args) != 1:
     parser.print_help()
-    return 1
+    return SCAN_ERRORS
 
   if args[0] == 'scan':
-    if _Scan():
+    scan_result = _Scan()
+    if scan_result == SCAN_OK:
       print 'OK!'
-      return 0
-    else:
-      return 1
+    return scan_result
   elif args[0] == 'notice':
     print GenerateNoticeFile()
-    return 0
+    return SCAN_OK
 
   parser.print_help()
-  return 1
+  return SCAN_ERRORS
 
 if __name__ == '__main__':
   sys.exit(main())