utils Namespace Reference

Classes
class	BaseCoreDumpArchiver
class	chdir
class	Error
class	git_branch
class	IncreasedNumberOfFileDescriptors
class	LinuxCoreDumpArchiver
class	LinuxCoreDumpEnabler
class	MacOSCoreDumpArchiver
class	PosixCoreDumpArchiver
class	PosixCoreDumpEnabler
class	print_timings
class	TempDir
class	tmp_dir
class	UnexpectedCrash
class	Version
class	WindowsCoreDumpArchiver
class	WindowsCoreDumpEnabler

Functions
def	GuessOS ()
def	GuessArchitecture ()
def	GuessCpus ()
def	IsWindows ()
def	ReadLinesFrom (name)
def	ListArgCallback (option, opt_str, value, parser)
def	ListDashArgCallback (option, opt_str, value, parser)
def	GetBuildMode (mode)
def	GetBuildConf (mode, arch)
def	GetBuildRoot (host_os, mode=None, arch=None, sanitizer=None)
def	RunCommand (command, input=None, pollFn=None, outStream=None, errStream=None, killOnEarlyReturn=True, verbose=False, debug=False, printErrorInfo=False)
def	Main (argv)
def	GetArchFamily (arch)
def	GetBuildDir (host_os)
def	GetBuildSanitizer (sanitizer)
def	GetBaseDir ()
def	load_source (modname, filename)
def	GetBotUtils (repo_path=DART_DIR)
def	GetMinidumpUtils (repo_path=DART_DIR)
def	IsRosetta ()
def	HostArchitectures ()
def	IsCrossBuild (target_os, arch)
def	GetBuildConf (mode, arch, conf_os=None, sanitizer=None)
def	GetBuildRoot (host_os, mode=None, arch=None, target_os=None, sanitizer=None)
def	GetVersion (no_git_hash=False, version_file=None, git_revision_file=None)
def	GetChannel (version_file=None)
def	ReadVersionFile (version_file=None)
def	GetGitRevision (git_revision_file=None, repo_path=DART_DIR)
def	GetShortGitHash (repo_path=DART_DIR)
def	GetGitTimestamp (git_timestamp_file=None, repo_path=DART_DIR)
def	IsCrashExitCode (exit_code)
def	DiagnoseExitCode (exit_code, command)
def	CheckedInSdkPath ()
def	CheckedInSdkExecutable ()
def	CheckLinuxCoreDumpPattern (fatal=False)
def	TryUnlink (file)
def	NooptContextManager ()
def	CoreDumpArchiver (args)
def	FileDescriptorLimitIncreaser ()
def	Main ()
def	git_clone (repo_url, dest_dir)
def	RemoveDirectory (*path)

Variables
dictionary	BUILD_MODES
dictionary	BUILD_ROOT
string	SEMANTIC_VERSION_PATTERN = r'^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$'
int	GIT_NUMBER_BASE = 100000
dictionary	BUILD_SANITIZERS
dictionary	ARCH_FAMILY
	BASE_DIR = os.path.abspath(os.path.join(os.curdir, '..'))
	DART_DIR = os.path.abspath(os.path.join(__file__, '..', '..'))
	VERSION_FILE = os.path.join(DART_DIR, 'tools', 'VERSION')
string	SKIA_REPO = 'https://skia.googlesource.com/skia.git'
string	GCLIENT = 'win32' else 'gclient'
string	WHICH = 'win32' else 'which'
	GIT = subprocess.check_output([WHICH, 'git']).decode('utf-8').splitlines()[0]

Function Documentation

CheckedInSdkExecutable()

def utils.CheckedInSdkExecutable

(

)

Definition at line 504 of file utils.py.

def CheckedInSdkExecutable():
    name = 'dart'
    if IsWindows():
        name = 'dart.exe'
    return os.path.join(CheckedInSdkPath(), 'bin', name)
 
 

CheckedInSdkPath()

def utils.CheckedInSdkPath

(

)

Definition at line 499 of file utils.py.

def CheckedInSdkPath():
    tools_dir = os.path.dirname(os.path.realpath(__file__))
    return os.path.join(tools_dir, 'sdks', 'dart-sdk')
 
 

CheckLinuxCoreDumpPattern()

def utils.CheckLinuxCoreDumpPattern

(

fatal = False

)

Definition at line 511 of file utils.py.

def CheckLinuxCoreDumpPattern(fatal=False):
    core_pattern_file = '/proc/sys/kernel/core_pattern'
    core_pattern = open(core_pattern_file).read()
 
    expected_core_pattern = 'core.%p'
    if core_pattern.strip() != expected_core_pattern:
        message = (
            'Invalid core_pattern configuration. '
            'The configuration of core dump handling is *not* correct for '
            'a buildbot. The content of {0} must be "{1}" instead of "{2}".'.
            format(core_pattern_file, expected_core_pattern, core_pattern))
        if fatal:
            raise Exception(message)
        print(message)
        return False
    return True
 
 

CoreDumpArchiver()

def utils.CoreDumpArchiver

(

args

)

Definition at line 973 of file utils.py.

def CoreDumpArchiver(args):
    enabled = '--copy-coredumps' in args
    prefix = '--output-directory='
    output_directory = next(
        (arg[len(prefix):] for arg in args if arg.startswith(prefix)), None)
 
    if not enabled:
        return (NooptContextManager(),)
 
    osname = GuessOS()
    if osname == 'linux':
        return (LinuxCoreDumpEnabler(), LinuxCoreDumpArchiver(output_directory))
    elif osname == 'macos':
        return (PosixCoreDumpEnabler(), MacOSCoreDumpArchiver(output_directory))
    elif osname == 'win32':
        return (WindowsCoreDumpEnabler(),
                WindowsCoreDumpArchiver(output_directory))
 
    # We don't have support for MacOS yet.
    return (NooptContextManager(),)
 
 

DiagnoseExitCode()

def utils.DiagnoseExitCode	(		exit_code,
			command
	)

Definition at line 492 of file utils.py.

def DiagnoseExitCode(exit_code, command):
    if IsCrashExitCode(exit_code):
        sys.stderr.write(
            'Command: {}\nCRASHED with exit code {} (0x{:x})\n'.format(
                ' '.join(command), exit_code, exit_code & 0xffffffff))
 
 

FileDescriptorLimitIncreaser()

def utils.FileDescriptorLimitIncreaser

(

)

Definition at line 995 of file utils.py.

def FileDescriptorLimitIncreaser():
    osname = GuessOS()
    if osname == 'macos':
        return IncreasedNumberOfFileDescriptors(nofiles=10000)
 
    assert osname in ('linux', 'win32')
    # We don't have support for MacOS yet.
    return NooptContextManager()
 
 

GetArchFamily()

def utils.GetArchFamily

(

arch

)

Definition at line 95 of file utils.py.

def GetArchFamily(arch):
    return ARCH_FAMILY[arch]
 
 

GetBaseDir()

def utils.GetBaseDir

(

)

Definition at line 111 of file utils.py.

def GetBaseDir():
    return BASE_DIR
 
 

GetBotUtils()

def utils.GetBotUtils

(

repo_path = DART_DIR

)

Dynamically load the tools/bots/bot_utils.py python module.

Definition at line 128 of file utils.py.

def GetBotUtils(repo_path=DART_DIR):
    '''Dynamically load the tools/bots/bot_utils.py python module.'''
    return load_source('bot_utils',
                       os.path.join(repo_path, 'tools', 'bots', 'bot_utils.py'))
 
 

GetBuildConf() [1/2]

def utils.GetBuildConf	(		mode,
			arch
	)

Definition at line 139 of file utils.py.

def GetBuildConf(mode, arch):
    return GetBuildMode(mode) + arch.upper()
 
 

GetBuildConf() [2/2]

def utils.GetBuildConf	(		mode,
			arch,
			conf_os = None,
			sanitizer = None
	)

Definition at line 336 of file utils.py.

def GetBuildConf(mode, arch, conf_os=None, sanitizer=None):
    if conf_os is not None and conf_os != GuessOS() and conf_os != 'host':
        return '{}{}{}'.format(GetBuildMode(mode), conf_os.title(),
                               arch.upper())
 
    # Ask for a cross build if the host and target architectures don't match.
    cross_build = ''
    if IsCrossBuild(conf_os, arch):
        cross_build = 'X'
    return '{}{}{}{}'.format(GetBuildMode(mode), GetBuildSanitizer(sanitizer),
                             cross_build, arch.upper())
 
 

GetBuildDir()

def utils.GetBuildDir

(

host_os

)

Definition at line 99 of file utils.py.

def GetBuildDir(host_os):
    return BUILD_ROOT[host_os]
 
 

GetBuildMode()

def utils.GetBuildMode

(

mode

)

Definition at line 134 of file utils.py.

def GetBuildMode(mode):
    global BUILD_MODES
    return BUILD_MODES[mode]
 
 

GetBuildRoot() [1/2]

def utils.GetBuildRoot	(		host_os,
			mode = None,
			arch = None,
			sanitizer = None
	)

Definition at line 143 of file utils.py.

def GetBuildRoot(host_os, mode=None, arch=None, sanitizer=None):
    global BUILD_ROOT
    if mode:
        return os.path.join(BUILD_ROOT[host_os],
                            GetBuildConf(mode, arch, sanitizer))
    else:
        return BUILD_ROOT[host_os]
 
 

GetBuildRoot() [2/2]

def utils.GetBuildRoot	(		host_os,
			mode = None,
			arch = None,
			target_os = None,
			sanitizer = None
	)

Definition at line 349 of file utils.py.

def GetBuildRoot(host_os, mode=None, arch=None, target_os=None, sanitizer=None):
    build_root = GetBuildDir(host_os)
    if mode:
        build_root = os.path.join(
            build_root, GetBuildConf(mode, arch, target_os, sanitizer))
    return build_root
 
 

GetBuildSanitizer()

def utils.GetBuildSanitizer

(

sanitizer

)

Definition at line 107 of file utils.py.

def GetBuildSanitizer(sanitizer):
    return BUILD_SANITIZERS[sanitizer]
 
 

GetChannel()

def utils.GetChannel

(

version_file = None

)

Definition at line 376 of file utils.py.

def GetChannel(version_file=None):
    version = ReadVersionFile(version_file)
    return version.channel
 
 

GetGitRevision()

def utils.GetGitRevision	(		git_revision_file = None,
			repo_path = DART_DIR
	)

Definition at line 415 of file utils.py.

def GetGitRevision(git_revision_file=None, repo_path=DART_DIR):
    # When building from tarball use tools/GIT_REVISION
    if git_revision_file is None:
        git_revision_file = os.path.join(repo_path, 'tools', 'GIT_REVISION')
    try:
        with open(git_revision_file) as fd:
            return fd.read().strip()
    except:
        pass
    p = subprocess.Popen(['git', 'rev-parse', 'HEAD'],
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE,
                         shell=IsWindows(),
                         cwd=repo_path)
    out, err = p.communicate()
    # TODO(https://github.com/dart-lang/sdk/issues/51865): Don't ignore errors.
    # if p.wait() != 0:
    #    raise Exception('git rev-parse failed: ' + str(err))
    revision = out.decode('utf-8').strip()
    # We expect a full git hash
    if len(revision) != 40:
        print('Warning: Could not parse git commit, output was {}'.format(
            revision),
              file=sys.stderr)
        return None
    return revision
 
 

GetGitTimestamp()

def utils.GetGitTimestamp	(		git_timestamp_file = None,
			repo_path = DART_DIR
	)

Definition at line 458 of file utils.py.

def GetGitTimestamp(git_timestamp_file=None, repo_path=DART_DIR):
    # When building from tarball use tools/GIT_TIMESTAMP
    if git_timestamp_file is None:
        git_timestamp_file = os.path.join(repo_path, 'tools', 'GIT_TIMESTAMP')
    try:
        with open(git_timestamp_file) as fd:
            return fd.read().strip()
    except:
        pass
    p = subprocess.Popen(['git', 'log', '-n', '1', '--pretty=format:%cd'],
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE,
                         shell=IsWindows(),
                         cwd=repo_path)
    out, err = p.communicate()
    if p.wait() != 0:
        # TODO(https://github.com/dart-lang/sdk/issues/51865): Don't ignore errors.
        # raise Exception('git log failed: ' + str(err))
        return None
    timestamp = out.decode('utf-8').strip()
    return timestamp
 
 
# TODO(42528): Can we remove this? It's basically just an alias for Exception.

GetMinidumpUtils()

def utils.GetMinidumpUtils

(

repo_path = DART_DIR

)

Dynamically load the tools/minidump.py python module.

Definition at line 134 of file utils.py.

def GetMinidumpUtils(repo_path=DART_DIR):
    '''Dynamically load the tools/minidump.py python module.'''
    return load_source('minidump',
                       os.path.join(repo_path, 'tools', 'minidump.py'))
 
 
@total_ordering

GetShortGitHash()

def utils.GetShortGitHash

(

repo_path = DART_DIR

)

Definition at line 443 of file utils.py.

def GetShortGitHash(repo_path=DART_DIR):
    p = subprocess.Popen(['git', 'rev-parse', '--short=10', 'HEAD'],
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE,
                         shell=IsWindows(),
                         cwd=repo_path)
    out, err = p.communicate()
    if p.wait() != 0:
        # TODO(https://github.com/dart-lang/sdk/issues/51865): Don't ignore errors.
        # raise Exception('git rev-parse failed: ' + str(err))
        return None
    revision = out.decode('utf-8').strip()
    return revision
 
 

GetVersion()

def utils.GetVersion	(		no_git_hash = False,
			version_file = None,
			git_revision_file = None
	)

Definition at line 357 of file utils.py.

def GetVersion(no_git_hash=False, version_file=None, git_revision_file=None):
    version = ReadVersionFile(version_file)
    if not version:
        return None
 
    suffix = ''
    if version.channel in ['main', 'be']:
        suffix = '-edge' if no_git_hash else '-edge.{}'.format(
            GetGitRevision(git_revision_file))
    elif version.channel in ('beta', 'dev'):
        suffix = '-{}.{}.{}'.format(version.prerelease,
                                    version.prerelease_patch, version.channel)
    else:
        assert version.channel == 'stable'
 
    return '{}.{}.{}{}'.format(version.major, version.minor, version.patch,
                               suffix)
 
 

git_clone()

def utils.git_clone	(		repo_url,
			dest_dir
	)

Clone the given repo into the given destination directory.

Definition at line 77 of file utils.py.

def git_clone(repo_url, dest_dir):
  """Clone the given repo into the given destination directory."""
  subprocess.check_call([GIT, 'clone', repo_url, dest_dir])
 
 

GuessArchitecture()

def utils.GuessArchitecture

(

)

Definition at line 42 of file utils.py.

def GuessArchitecture():
    id = platform.machine()
    if id.startswith('arm'):
        return 'arm'
    elif (not id) or (not re.match('(x|i[3-6])86', id) is None):
        return 'ia32'
    elif id == 'i86pc':
        return 'ia32'
    else:
        return None
 
 
# Try to guess the number of cpus on this machine.

GuessCpus()

def utils.GuessCpus

(

)

Definition at line 55 of file utils.py.

def GuessCpus():
    if os.path.exists("/proc/cpuinfo"):
        return int(
            getoutput(
                "GREP_OPTIONS= grep -E '^processor' /proc/cpuinfo | wc -l"))
    if os.path.exists("/usr/bin/hostinfo"):
        return int(
            getoutput(
                '/usr/bin/hostinfo | GREP_OPTIONS= grep "processors are logically available." | awk "{ print \\$1 }"'
            ))
    win_cpu_count = os.getenv("NUMBER_OF_PROCESSORS")
    if win_cpu_count:
        return int(win_cpu_count)
    return int(os.getenv("DART_NUMBER_OF_CORES", 2))
 
 
# Returns true if we're running under Windows.

GuessOS()

def utils.GuessOS

(

)

Definition at line 21 of file utils.py.

def GuessOS():
    id = platform.system()
    if id == "Linux":
        return "linux"
    elif id == "Darwin":
        return "macos"
    elif id == "Windows" or id == "Microsoft":
        # On Windows Vista platform.system() can return "Microsoft" with some
        # versions of Python, see http://bugs.python.org/issue1082 for details.
        return "win32"
    elif id == 'FreeBSD':
        return 'freebsd'
    elif id == 'OpenBSD':
        return 'openbsd'
    elif id == 'SunOS':
        return 'solaris'
    else:
        return None
 
 
# Try to guess the host architecture.

HostArchitectures()

def utils.HostArchitectures

(

)

Definition at line 263 of file utils.py.

def HostArchitectures():
    m = platform.machine()
    if platform.system() == 'Darwin':
        if m == 'arm64' or IsRosetta():
            # ARM64 Macs also support X64.
            return ['arm64', 'x64']
        if m == 'x86_64':
            # X64 Macs no longer support IA32.
            return ['x64']
    # Icky use of CIPD_ARCHITECTURE should be effectively dead whenever the
    # Python on bots becomes native ARM64.
    if ((platform.system() == 'Windows') and
        (os.environ.get("CIPD_ARCHITECTURE") == "arm64")):
        # ARM64 Windows also can emulate X64.
        return ['arm64', 'x64']
 
    if m in ['aarch64', 'arm64', 'arm64e', 'ARM64']:
        return ['arm64']
    if m in ['armv7l', 'armv8l']:
        return ['arm']
    if m in ['i386', 'i686', 'ia32', 'x86']:
        return ['x86', 'ia32']
    if m in ['x64', 'x86-64', 'x86_64', 'amd64', 'AMD64']:
        return ['x64', 'x86', 'ia32']
    if m in ['riscv64']:
        return ['riscv64']
    raise Exception('Failed to determine host architectures for %s %s',
                    platform.machine(), platform.system())
 
 
# Try to guess the host architecture.

IsCrashExitCode()

def utils.IsCrashExitCode

(

exit_code

)

Definition at line 486 of file utils.py.

def IsCrashExitCode(exit_code):
    if IsWindows():
        return 0x80000000 & exit_code
    return exit_code < 0
 
 

IsCrossBuild()

def utils.IsCrossBuild	(		target_os,
			arch
	)

Definition at line 323 of file utils.py.

def IsCrossBuild(target_os, arch):
    if (target_os not in [None, 'host']) and (target_os != GuessOS()):
        return True
    if arch.startswith('sim'):
        return False
    if arch.endswith('c'):
        # Strip 'compressed' suffix.
        arch = arch[:-1]
    if arch in HostArchitectures():
        return False
    return True
 
 

IsRosetta()

def utils.IsRosetta

(

)

Definition at line 252 of file utils.py.

def IsRosetta():
    if platform.system() == 'Darwin':
        p = subprocess.Popen(['sysctl', '-in', 'sysctl.proc_translated'],
                             stdout=subprocess.PIPE,
                             stderr=subprocess.STDOUT)
        output, _ = p.communicate()
        return output.decode('utf-8').strip() == '1'
    return False
 
 
# Returns the architectures that can run on the current machine.

IsWindows()

def utils.IsWindows

(

)

Definition at line 72 of file utils.py.

def IsWindows():
    return GuessOS() == 'win32'
 
 
# Reads a text file into an array of strings - one for each
# line. Strips comments in the process.

ListArgCallback()

def utils.ListArgCallback	(		option,
			opt_str,
			value,
			parser
	)

Definition at line 92 of file utils.py.

def ListArgCallback(option, opt_str, value, parser):
    if value is None:
        value = []
 
    for arg in parser.rargs:
        if arg[:2].startswith('--'):
            break
        value.append(arg)
 
    del parser.rargs[:len(value)]
    setattr(parser.values, option.dest, value)
 
 
# Filters out all argument until the first non '-' or the
# '--' argument occurs.

ListDashArgCallback()

def utils.ListDashArgCallback	(		option,
			opt_str,
			value,
			parser
	)

Definition at line 107 of file utils.py.

def ListDashArgCallback(option, opt_str, value, parser):
    if value is None:
        value = []
 
    for arg in parser.rargs:
        if arg[:2].startswith('--') or arg[0] != '-':
            break
        value.append(arg)
 
    del parser.rargs[:len(value)]
    setattr(parser.values, option.dest, value)
 
 
# Mapping table between build mode and build configuration.

load_source()

def utils.load_source	(		modname,
			filename
	)

Definition at line 115 of file utils.py.

def load_source(modname, filename):
    loader = importlib.machinery.SourceFileLoader(modname, filename)
    spec = importlib.util.spec_from_file_location(modname,
                                                  filename,
                                                  loader=loader)
    module = importlib.util.module_from_spec(spec)
    # The module is always executed and not cached in sys.modules.
    # Uncomment the following line to cache the module.
    # sys.modules[module.__name__] = module
    loader.exec_module(module)
    return module
 
 

Main() [1/2]

def utils.Main

(

)

Definition at line 1005 of file utils.py.

def Main():
    print('GuessOS() -> ', GuessOS())
    print('GuessArchitecture() -> ', GuessArchitecture())
    print('GuessCpus() -> ', GuessCpus())
    print('IsWindows() -> ', IsWindows())
    print('GetGitRevision() -> ', GetGitRevision())
    print('GetGitTimestamp() -> ', GetGitTimestamp())
    print('ReadVersionFile() -> ', ReadVersionFile())
 
 

Main() [2/2]

def utils.Main

(

argv

)

Definition at line 268 of file utils.py.

def Main(argv):
    print("GuessOS() -> ", GuessOS())
    print("GuessArchitecture() -> ", GuessArchitecture())
    print("GuessCpus() -> ", GuessCpus())
    print("IsWindows() -> ", IsWindows())
 
 

NooptContextManager()

def utils.NooptContextManager

(

)

Definition at line 969 of file utils.py.

def NooptContextManager():
    yield
 
 

ReadLinesFrom()

def utils.ReadLinesFrom

(

name

)

Definition at line 78 of file utils.py.

def ReadLinesFrom(name):
    result = []
    for line in open(name):
        if '#' in line:
            line = line[:line.find('#')]
        line = line.strip()
        if len(line) == 0:
            continue
        result.append(line)
    return result
 
 
# Filters out all arguments until the next '--' argument
# occurs.

ReadVersionFile()

def utils.ReadVersionFile

(

version_file = None

)

Definition at line 381 of file utils.py.

def ReadVersionFile(version_file=None):
 
    def match_against(pattern, file_content):
        match = re.search(pattern, file_content, flags=re.MULTILINE)
        if match:
            return match.group(1)
        return None
 
    if version_file == None:
        version_file = VERSION_FILE
 
    content = None
    try:
        with open(version_file) as fd:
            content = fd.read()
    except:
        print('Warning: Could not read VERSION file ({})'.format(version_file))
        return None
 
    channel = match_against('^CHANNEL ([A-Za-z0-9]+)$', content)
    major = match_against('^MAJOR (\\d+)$', content)
    minor = match_against('^MINOR (\\d+)$', content)
    patch = match_against('^PATCH (\\d+)$', content)
    prerelease = match_against('^PRERELEASE (\\d+)$', content)
    prerelease_patch = match_against('^PRERELEASE_PATCH (\\d+)$', content)
 
    if (channel and major and minor and prerelease and prerelease_patch):
        return Version(channel, major, minor, patch, prerelease,
                       prerelease_patch)
 
    print('Warning: VERSION file ({}) has wrong format'.format(version_file))
    return None
 
 

RemoveDirectory()

def utils.RemoveDirectory

(

*

path

)

Recursively removes a directory, even if it's marked read-only.

This was copied from:
https://chromium.googlesource.com/chromium/tools/build/+/f3e7ff03613cd59a463b2ccc49773c3813e77404/scripts/common/chromium_utils.py#491

Remove the directory located at *path, if it exists.

shutil.rmtree() doesn't work on Windows if any of the files or directories
are read-only, which svn repositories and some .svn files are.  We need to
be able to force the files to be writable (i.e., deletable) as we traverse
the tree.

Even with all this, Windows still sometimes fails to delete a file, citing
a permission error (maybe something to do with antivirus scans or disk
indexing).  The best suggestion any of the user forums had was to wait a
bit and try again, so we do that too.  It's hand-waving, but sometimes it
works. :/

Definition at line 118 of file utils.py.

def RemoveDirectory(*path):
  """Recursively removes a directory, even if it's marked read-only.
 
  This was copied from:
  https://chromium.googlesource.com/chromium/tools/build/+/f3e7ff03613cd59a463b2ccc49773c3813e77404/scripts/common/chromium_utils.py#491
 
  Remove the directory located at *path, if it exists.
 
  shutil.rmtree() doesn't work on Windows if any of the files or directories
  are read-only, which svn repositories and some .svn files are.  We need to
  be able to force the files to be writable (i.e., deletable) as we traverse
  the tree.
 
  Even with all this, Windows still sometimes fails to delete a file, citing
  a permission error (maybe something to do with antivirus scans or disk
  indexing).  The best suggestion any of the user forums had was to wait a
  bit and try again, so we do that too.  It's hand-waving, but sometimes it
  works. :/
  """
  file_path = os.path.join(*path)
  if not os.path.exists(file_path):
    return
 
  if sys.platform == 'win32':
    # Give up and use cmd.exe's rd command.
    file_path = os.path.normcase(file_path)
    for _ in range(3):
      print('RemoveDirectory running %s' % (' '.join(
          ['cmd.exe', '/c', 'rd', '/q', '/s', file_path])))
      if not subprocess.call(['cmd.exe', '/c', 'rd', '/q', '/s', file_path]):
        break
      print('  Failed')
      time.sleep(3)
    return
 
  def RemoveWithRetry_non_win(rmfunc, path):
    if os.path.islink(path):
      return os.remove(path)
    else:
      return rmfunc(path)
 
  remove_with_retry = RemoveWithRetry_non_win
 
  def RmTreeOnError(function, path, excinfo):
    r"""This works around a problem whereby python 2.x on Windows has no ability
    to check for symbolic links.  os.path.islink always returns False.  But
    shutil.rmtree will fail if invoked on a symbolic link whose target was
    deleted before the link.  E.g., reproduce like this:
    > mkdir test
    > mkdir test\1
    > mklink /D test\current test\1
    > python -c "import chromium_utils; chromium_utils.RemoveDirectory('test')"
    To avoid this issue, we pass this error-handling function to rmtree.  If
    we see the exact sort of failure, we ignore it.  All other failures we re-
    raise.
    """
 
    exception_type = excinfo[0]
    exception_value = excinfo[1]
    # If shutil.rmtree encounters a symbolic link on Windows, os.listdir will
    # fail with a WindowsError exception with an ENOENT errno (i.e., file not
    # found).  We'll ignore that error.  Note that WindowsError is not defined
    # for non-Windows platforms, so we use OSError (of which it is a subclass)
    # to avoid lint complaints about an undefined global on non-Windows
    # platforms.
    if (function is os.listdir) and issubclass(exception_type, OSError):
      if exception_value.errno == errno.ENOENT:
        # File does not exist, and we're trying to delete, so we can ignore the
        # failure.
        print('WARNING:  Failed to list %s during rmtree.  Ignoring.\n' % path)
      else:
        raise
    else:
      raise
 
  for root, dirs, files in os.walk(file_path, topdown=False):
    # For POSIX:  making the directory writable guarantees removability.
    # Windows will ignore the non-read-only bits in the chmod value.
    os.chmod(root, 0o770)
    for name in files:
      remove_with_retry(os.remove, os.path.join(root, name))
    for name in dirs:
      remove_with_retry(lambda p: shutil.rmtree(p, onerror=RmTreeOnError),
                        os.path.join(root, name))
 
  remove_with_retry(os.rmdir, file_path)

RunCommand()

def utils.RunCommand	(		command,
			input = None,
			pollFn = None,
			outStream = None,
			errStream = None,
			killOnEarlyReturn = True,
			verbose = False,
			debug = False,
			printErrorInfo = False
	)

Run a command, with optional input and polling function.

Args:
command: list of the command and its arguments.
input: optional string of input to feed to the command, it should be
    short enough to fit in an i/o pipe buffer.
pollFn: if present will be called occasionally to check if the command
    should be finished early. If pollFn() returns true then the command
    will finish early.
outStream: if present, the stdout output of the command will be written to
    outStream.
errStream: if present, the stderr output of the command will be written to
    errStream.
killOnEarlyReturn: if true and pollFn returns true, then the subprocess will
    be killed, otherwise the subprocess will be detached.
verbose: if true, the command is echoed to stderr.
debug: if true, prints debugging information to stderr.
printErrorInfo: if true, prints error information when the subprocess
returns a non-zero exit code.
Returns: the output of the subprocess.

Exceptions:
Raises Error if the subprocess returns an error code.
Raises ValueError if called with invalid arguments.

Definition at line 152 of file utils.py.

               printErrorInfo=False):
    """
  Run a command, with optional input and polling function.
 
  Args:
    command: list of the command and its arguments.
    input: optional string of input to feed to the command, it should be
        short enough to fit in an i/o pipe buffer.
    pollFn: if present will be called occasionally to check if the command
        should be finished early. If pollFn() returns true then the command
        will finish early.
    outStream: if present, the stdout output of the command will be written to
        outStream.
    errStream: if present, the stderr output of the command will be written to
        errStream.
    killOnEarlyReturn: if true and pollFn returns true, then the subprocess will
        be killed, otherwise the subprocess will be detached.
    verbose: if true, the command is echoed to stderr.
    debug: if true, prints debugging information to stderr.
    printErrorInfo: if true, prints error information when the subprocess
    returns a non-zero exit code.
  Returns: the output of the subprocess.
 
  Exceptions:
    Raises Error if the subprocess returns an error code.
    Raises ValueError if called with invalid arguments.
  """
    if verbose:
        sys.stderr.write("command %s\n" % command)
    stdin = None
    if input:
        stdin = subprocess.PIPE
    try:
        process = subprocess.Popen(
            args=command,
            stdin=stdin,
            bufsize=1,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE)
    except OSError as e:
        if not isinstance(command, str):
            command = ' '.join(command)
        if printErrorInfo:
            sys.stderr.write("Command failed: '%s'\n" % command)
        raise Error(e)
 
    def StartThread(out):
        queue = queue.Queue()
 
        def EnqueueOutput(out, queue):
            for line in iter(out.readline, b''):
                queue.put(line)
            out.close()
 
        thread = threading.Thread(target=EnqueueOutput, args=(out, queue))
        thread.daemon = True
        thread.start()
        return queue
 
    outQueue = StartThread(process.stdout)
    errQueue = StartThread(process.stderr)
 
    def ReadQueue(queue, out, out2):
        try:
            while True:
                line = queue.get(False)
                out.write(line)
                if out2 != None:
                    out2.write(line)
        except queue.Empty:
            pass
 
    outBuf = StringIO.StringIO()
    errorBuf = StringIO.StringIO()
    if input:
        process.stdin.write(input)
    while True:
        returncode = process.poll()
        if returncode != None:
            break
        ReadQueue(errQueue, errorBuf, errStream)
        ReadQueue(outQueue, outBuf, outStream)
        if pollFn != None and pollFn():
            returncode = 0
            if killOnEarlyReturn:
                process.kill()
            break
        time.sleep(0.1)
    # Drain queue
    ReadQueue(errQueue, errorBuf, errStream)
    ReadQueue(outQueue, outBuf, outStream)
 
    out = outBuf.getvalue()
    error = errorBuf.getvalue()
    if returncode:
        if not isinstance(command, str):
            command = ' '.join(command)
        if printErrorInfo:
            sys.stderr.write("Command failed: '%s'\n" % command)
            sys.stderr.write("        stdout: '%s'\n" % out)
            sys.stderr.write("        stderr: '%s'\n" % error)
            sys.stderr.write("    returncode: %d\n" % returncode)
        raise Error("Command failed: %s" % command)
    if debug:
        sys.stderr.write("output: %s\n" % out)
    return out
 
 

TryUnlink()

def utils.TryUnlink

(

file

)

Definition at line 603 of file utils.py.

def TryUnlink(file):
    try:
        os.unlink(file)
    except Exception as error:
        print('ERROR: Failed to remove {}: {}'.format(file, error))
 
 

Variable Documentation

ARCH_FAMILY

dictionary utils.ARCH_FAMILY

Initial value:

=  {
    'ia32': 'ia32',
    'x64': 'ia32',
    'arm': 'arm',
    'arm64': 'arm',
    'arm_x64': 'arm',
    'arm_arm64': 'arm',
    'simarm': 'ia32',
    'simarm64': 'ia32',
    'simarm_x64': 'ia32',
    'simarm_arm64': 'arm',
    'x64c': 'ia32',
    'arm64c': 'arm',
    'simarm64c': 'ia32',
    'simriscv32': 'ia32',
    'simriscv64': 'ia32',
    'simx64': 'arm',
    'simx64c': 'arm',
    'riscv32': 'riscv',
    'riscv64': 'riscv',
}

Definition at line 68 of file utils.py.

BASE_DIR

utils.BASE_DIR = os.path.abspath(os.path.join(os.curdir, '..'))

Definition at line 90 of file utils.py.

BUILD_MODES

dictionary utils.BUILD_MODES

Initial value:

=  {
    'debug': 'Debug',
    'release': 'Release',
}

Definition at line 121 of file utils.py.

BUILD_ROOT

dictionary utils.BUILD_ROOT

Initial value:

=  {
    'linux': os.path.join('out'),
    'freebsd': os.path.join('out'),
    'macos': os.path.join('xcodebuild'),
}

Definition at line 127 of file utils.py.

BUILD_SANITIZERS

dictionary utils.BUILD_SANITIZERS

Initial value:

=  {
    None: '',
    'none': '',
    'asan': 'ASAN',
    'lsan': 'LSAN',
    'msan': 'MSAN',
    'tsan': 'TSAN',
    'ubsan': 'UBSAN',
}

Definition at line 49 of file utils.py.

DART_DIR

utils.DART_DIR = os.path.abspath(os.path.join(__file__, '..', '..'))

Definition at line 91 of file utils.py.

GCLIENT

string utils.GCLIENT = 'win32' else 'gclient'

Definition at line 23 of file utils.py.

GIT

utils.GIT = subprocess.check_output([WHICH, 'git']).decode('utf-8').splitlines()[0]

Definition at line 25 of file utils.py.

GIT_NUMBER_BASE

int utils.GIT_NUMBER_BASE = 100000

Definition at line 39 of file utils.py.

SEMANTIC_VERSION_PATTERN

string utils.SEMANTIC_VERSION_PATTERN = r'^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$'

Definition at line 33 of file utils.py.

SKIA_REPO

string utils.SKIA_REPO = 'https://skia.googlesource.com/skia.git'

Definition at line 21 of file utils.py.

VERSION_FILE

utils.VERSION_FILE = os.path.join(DART_DIR, 'tools', 'VERSION')

Definition at line 92 of file utils.py.

WHICH

string utils.WHICH = 'win32' else 'which'

Definition at line 24 of file utils.py.