def __main(args: list) -> int:
validate_supported_runtime()
args = __process_arguments(args)
verbose = not args.quiet
setup_loggers(verbose=verbose)
# if repository is not set, then we are doing a core-sdk in performance repo run
# if repository is set, user needs to supply the commit_sha
if not ((args.commit_sha is None) == (args.repository is None)):
raise ValueError(
'Either both commit_sha and repository should be set or neither')
# Acquire necessary tools (dotnet)
# For arm64 runs, download the x64 version so we can get the information we need, but set all variables
# as if we were running normally. This is a workaround due to the fact that arm64 binaries cannot run
# in the cross containers, so we are running the ci setup script in a normal ubuntu container
architecture = 'x64' if args.architecture == 'arm64' else args.architecture
init_tools(architecture=architecture,
dotnet_versions=args.dotnet_versions,
channel=args.channel,
verbose=verbose,
install_dir=args.install_dir)
# dotnet --info
dotnet.info(verbose=verbose)
# When running on internal repos, the repository comes to us incorrectly
# (ie https://github.com/dotnet-coreclr). Replace dashes with slashes in that case.
repo_url = None if args.repository is None else args.repository.replace(
'-', '/')
variable_format = 'set %s=%s\n' if sys.platform == 'win32' else 'export %s=%s\n'
path_variable = 'set PATH=%%PATH%%;%s\n' if sys.platform == 'win32' else 'export PATH=$PATH:%s\n'
dotnet_path = '%HELIX_CORRELATION_PAYLOAD%\dotnet' if sys.platform == 'win32' else '$HELIX_CORRELATION_PAYLOAD/dotnet'
owner, repo = ('dotnet', 'core-sdk') if args.repository is None else (
dotnet.get_repository(repo_url))
config_string = ';'.join(
args.build_configs) if sys.platform == 'win32' else '"%s"' % ';'.join(
args.build_configs)
output = ''
with push_dir(get_repo_root_path()):
output = check_output(['git', 'rev-parse', 'HEAD'])
decoded_lines = []
for line in output.splitlines():
decoded_lines = decoded_lines + [line.decode('utf-8')]
decoded_output = ''.join(decoded_lines)
perfHash = decoded_output if args.get_perf_hash else args.perf_hash
framework = ChannelMap.get_target_framework_moniker(args.channel)
if framework.startswith('netcoreapp'):
target_framework_moniker = dotnet.FrameworkAction.get_target_framework_moniker(
framework)
dotnet_version = dotnet.get_dotnet_version(target_framework_moniker,
args.cli)
commit_sha = dotnet.get_dotnet_sdk(
target_framework_moniker,
args.cli) if args.commit_sha is None else args.commit_sha
source_timestamp = dotnet.get_commit_date(target_framework_moniker,
commit_sha, repo_url)
branch = ChannelMap.get_branch(
args.channel) if not args.branch else args.branch
getLogger().info("Writing script to %s" % args.output_file)
with open(args.output_file, 'w') as out_file:
out_file.write(variable_format % ('PERFLAB_INLAB', '1'))
out_file.write(variable_format %
('PERFLAB_REPO', '/'.join([owner, repo])))
out_file.write(variable_format % ('PERFLAB_BRANCH', branch))
out_file.write(variable_format % ('PERFLAB_PERFHASH', perfHash))
out_file.write(variable_format % ('PERFLAB_HASH', commit_sha))
out_file.write(variable_format % ('PERFLAB_QUEUE', args.queue))
out_file.write(variable_format %
('PERFLAB_BUILDNUM', args.build_number))
out_file.write(variable_format %
('PERFLAB_BUILDARCH', args.architecture))
out_file.write(variable_format % ('PERFLAB_LOCALE', args.locale))
out_file.write(variable_format %
('PERFLAB_BUILDTIMESTAMP', source_timestamp))
out_file.write(variable_format %
('PERFLAB_CONFIGS', config_string))
out_file.write(variable_format %
('DOTNET_VERSION', dotnet_version))
out_file.write(variable_format %
('PERFLAB_TARGET_FRAMEWORKS', framework))
out_file.write(variable_format %
('DOTNET_CLI_TELEMETRY_OPTOUT', '1'))
out_file.write(variable_format % ('DOTNET_MULTILEVEL_LOOKUP', '0'))
out_file.write(variable_format % ('UseSharedCompilation', 'false'))
out_file.write(variable_format % ('DOTNET_ROOT', dotnet_path))
out_file.write(path_variable % dotnet_path)
else:
with open(args.output_file, 'w') as out_file:
out_file.write(variable_format % ('PERFLAB_INLAB', '0'))
out_file.write(variable_format %
('PERFLAB_TARGET_FRAMEWORKS', framework))
out_file.write(path_variable % dotnet_path)
# The '_Framework' is needed for specifying frameworks in proj files and for building tools later in the pipeline
__write_pipeline_variable('_Framework', framework)
def install(
architecture: str,
channels: list,
versions: str,
verbose: bool,
install_dir: str = None) -> None:
'''
Downloads dotnet cli into the tools folder.
'''
__log_script_header("Downloading DotNet Cli")
if not install_dir:
install_dir = __get_directory(architecture)
if not path.exists(install_dir):
makedirs(install_dir)
getLogger().info("DotNet Install Path: '%s'", install_dir)
# Download appropriate dotnet install script
dotnetInstallScriptExtension = '.ps1' if platform == 'win32' else '.sh'
dotnetInstallScriptName = 'dotnet-install' + dotnetInstallScriptExtension
url = 'https://dot.net/v1/'
dotnetInstallScriptUrl = url + dotnetInstallScriptName
dotnetInstallScriptPath = path.join(install_dir, dotnetInstallScriptName)
getLogger().info('Downloading %s', dotnetInstallScriptUrl)
count = 0
while count < 3:
try:
with urlopen(dotnetInstallScriptUrl, context=ssl._create_unverified_context()) as response:
if "html" in response.info()['Content-Type']:
count = count + 1
sleep(1) # sleep one second
continue
with open(dotnetInstallScriptPath, 'wb') as outfile:
outfile.write(response.read())
break
except Exception:
count = count + 1
sleep(1)
continue
if count == 3:
getLogger().error("Fatal error: could not download dotnet-install script")
raise Exception("Fatal error: could not download dotnet-install script")
if platform != 'win32':
chmod(dotnetInstallScriptPath, S_IRWXU)
dotnetInstallInterpreter = [
'powershell.exe',
'-NoProfile',
'-ExecutionPolicy', 'Bypass',
dotnetInstallScriptPath
] if platform == 'win32' else [dotnetInstallScriptPath]
# If Version is supplied, pull down the specified version
common_cmdline_args = dotnetInstallInterpreter + [
'-InstallDir', install_dir,
'-Architecture', architecture
]
# Install Runtime/SDKs
if versions:
for version in versions:
cmdline_args = common_cmdline_args + ['-Version', version]
RunCommand(cmdline_args, verbose=verbose, retry=1).run(
get_repo_root_path()
)
# Only check channels if versions are not supplied.
# When we supply a version, but still pull down with -Channel, we will use
# whichever sdk is newer. So if we are trying to check an older version,
# or if there is a new version between when we start a run and when we actually
# run, we will be testing the "wrong" version, ie, not the version we specified.
if (not versions) and channels:
for channel in channels:
cmdline_args = common_cmdline_args + ['-Channel', ChannelMap.get_branch(channel)]
if ChannelMap.get_quality_from_channel(channel) is not None:
cmdline_args += ['-Quality', ChannelMap.get_quality_from_channel(channel)]
RunCommand(cmdline_args, verbose=verbose, retry=1).run(
get_repo_root_path()
)
# Set DotNet Cli environment variables.
environ['DOTNET_CLI_TELEMETRY_OPTOUT'] = '1'
environ['DOTNET_MULTILEVEL_LOOKUP'] = '0'
environ['UseSharedCompilation'] = 'false'
environ['DOTNET_ROOT'] = install_dir
# Add installed dotnet cli to PATH
environ["PATH"] = install_dir + pathsep + environ["PATH"]
# If we have copied dotnet from a different machine, then it may not be
# marked as executable. Fix this.
if platform != 'win32':
chmod(path.join(install_dir, 'dotnet'), S_IRWXU)
