A programming framework for agentic AI
Add comprehensive GitHub Copilot instructions for AutoGen development (#7029)
Copilot29846cb26b58
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.mdnew file mode 100644index 000000000..752303147--- /dev/null+++ b/.github/copilot-instructions.md@@ -0,0 +1,226 @@+# AutoGen Multi-Agent AI Framework++AutoGen is a multi-language framework for creating AI agents that can act autonomously or work alongside humans. The project has separate Python and .NET implementations with their own development workflows.++Always reference these instructions first and fallback to search or bash commands only when you encounter unexpected information that does not match the info here.++## Working Effectively++### Prerequisites and Environment Setup++**CRITICAL**: Install both .NET 8.0 and 9.0 for full compatibility:+- Install uv package manager: `python3 -m pip install uv`+- Install .NET 9.0 SDK: `wget https://dot.net/v1/dotnet-install.sh && chmod +x dotnet-install.sh && ./dotnet-install.sh --channel 9.0`+- Install .NET 8.0 runtime: `./dotnet-install.sh --channel 8.0 --runtime dotnet && ./dotnet-install.sh --channel 8.0 --runtime aspnetcore`+- Update PATH: `export PATH="$HOME/.dotnet:$PATH"`++### Python Development Workflow++**Bootstrap and build Python environment:**+```bash+cd /home/runner/work/autogen/autogen/python+uv sync --all-extras # NEVER CANCEL: Takes 2 minutes. Set timeout to 300+ seconds.+source .venv/bin/activate+```++**Validate Python development:**+```bash+# Quick validation (under 1 second each)+poe format # Code formatting+poe lint # Linting with ruff++# Type checking - NEVER CANCEL these commands+poe mypy # Takes 6 minutes. Set timeout to 600+ seconds.+poe pyright # Takes 41 seconds. Set timeout to 120+ seconds.++# Individual package testing (core package example)+poe --directory ./packages/autogen-core test # Takes 10 seconds. Set timeout to 60+ seconds.++# Documentation - NEVER CANCEL+poe docs-build # Takes 1 minute 16 seconds. Set timeout to 300+ seconds.+```++**CRITICAL TIMING EXPECTATIONS:**+- **NEVER CANCEL**: Python environment setup takes 2 minutes minimum+- **NEVER CANCEL**: mypy type checking takes 6 minutes+- **NEVER CANCEL**: Documentation build takes 1+ minutes+- Format/lint tasks complete in under 1 second+- Individual package tests typically complete in 10-60 seconds++### .NET Development Workflow++**Bootstrap and build .NET environment:**+```bash+cd /home/runner/work/autogen/autogen/dotnet+export PATH="$HOME/.dotnet:$PATH"+dotnet restore # NEVER CANCEL: Takes 53 seconds. Set timeout to 300+ seconds.+dotnet build --configuration Release # NEVER CANCEL: Takes 53 seconds. Set timeout to 300+ seconds.+```++**Validate .NET development:**+```bash+# Unit tests - NEVER CANCEL+dotnet test --configuration Release --filter "Category=UnitV2" --no-build # Takes 25 seconds. Set timeout to 120+ seconds.++# Format check (if build fails)+dotnet format --verify-no-changes++# Run samples+cd samples/Hello+dotnet run+```++**CRITICAL TIMING EXPECTATIONS:**+- **NEVER CANCEL**: .NET restore takes 53 seconds minimum+- **NEVER CANCEL**: .NET build takes 53 seconds minimum+- **NEVER CANCEL**: .NET unit tests take 25 seconds minimum+- All build and test commands require appropriate timeouts++### Complete Validation Workflow++**Run full check suite (Python):**+```bash+cd /home/runner/work/autogen/autogen/python+source .venv/bin/activate+poe check # NEVER CANCEL: Runs all checks. Takes 7+ minutes total. Set timeout to 900+ seconds.+```++## Validation Scenarios++### Manual Validation Requirements+Always manually validate changes by running complete user scenarios after making modifications:++**Python validation scenarios:**+1. **Import test**: Verify core imports work:+ ```python+ from autogen_agentchat.agents import AssistantAgent+ from autogen_core import AgentRuntime+ from autogen_ext.models.openai import OpenAIChatCompletionClient+ ```++2. **AutoGen Studio test**: Verify web interface can start:+ ```bash+ autogenstudio ui --help # Should show help without errors+ ```++3. **Documentation test**: Build and verify docs generate without errors:+ ```bash+ poe docs-build && ls docs/build/index.html+ ```++**.NET validation scenarios:**+1. **Sample execution**: Run Hello sample to verify runtime works:+ ```bash+ cd dotnet/samples/Hello && dotnet run --help+ ```++2. **Build validation**: Ensure all projects compile:+ ```bash+ dotnet build --configuration Release --no-restore+ ```++3. **Test execution**: Run unit tests to verify functionality:+ ```bash+ dotnet test --filter "Category=UnitV2" --configuration Release --no-build+ ```++## Common Issues and Workarounds++### Network-Related Issues+- **Python tests may fail** with network errors (tiktoken downloads, Playwright browser downloads) in sandboxed environments - this is expected+- **Documentation intersphinx warnings** due to inability to reach external documentation sites - this is expected+- **Individual package tests work better** than full test suite in network-restricted environments++### .NET Runtime Issues+- **Requires both .NET 8.0 and 9.0**: Build uses 9.0 SDK but tests need 8.0 runtime+- **Global.json specifies 9.0.100**: Must install exact .NET 9.0 version or later+- **Path configuration critical**: Ensure `$HOME/.dotnet` is in PATH before system .NET++### Python Package Issues+- **Use uv exclusively**: Do not use pip/conda for dependency management+- **Virtual environment required**: Always activate `.venv` before running commands+- **Package workspace structure**: Project uses uv workspace with multiple packages++## Timing Reference++### Python Commands+| Command | Expected Time | Timeout | Notes |+|---------|---------------|---------|-------|+| `uv sync --all-extras` | 2 minutes | 300+ seconds | NEVER CANCEL |+| `poe mypy` | 6 minutes | 600+ seconds | NEVER CANCEL |+| `poe pyright` | 41 seconds | 120+ seconds | NEVER CANCEL |+| `poe docs-build` | 1 min 16 sec | 300+ seconds | NEVER CANCEL |+| `poe format` | <1 second | 30 seconds | Quick |+| `poe lint` | <1 second | 30 seconds | Quick |+| Individual package test | 10 seconds | 60+ seconds | May have network failures |++### .NET Commands+| Command | Expected Time | Timeout | Notes |+|---------|---------------|---------|-------|+| `dotnet restore` | 53 seconds | 300+ seconds | NEVER CANCEL |+| `dotnet build --configuration Release` | 53 seconds | 300+ seconds | NEVER CANCEL |+| `dotnet test --filter "Category=UnitV2"` | 25 seconds | 120+ seconds | NEVER CANCEL |+| `dotnet format --verify-no-changes` | 5-10 seconds | 60 seconds | Quick validation |++## Repository Structure++### Python Packages (`python/packages/`)+- `autogen-core`: Core agent runtime, model interfaces, and base components+- `autogen-agentchat`: High-level multi-agent conversation APIs+- `autogen-ext`: Extensions for specific model providers and tools+- `autogen-studio`: Web-based IDE for agent workflows+- `agbench`: Benchmarking suite for agent performance+- `magentic-one-cli`: Multi-agent team CLI application++### .NET Projects (`dotnet/src/`)+- `AutoGen`: Legacy 0.2-style .NET packages (being deprecated)+- `Microsoft.AutoGen.*`: New event-driven .NET packages+- `AutoGen.Core`: Core .NET agent functionality+- Multiple provider packages: OpenAI, Anthropic, Ollama, etc.++### Key Configuration Files+- `python/pyproject.toml`: Python workspace and tool configuration+- `dotnet/global.json`: .NET SDK version requirements+- `dotnet/AutoGen.sln`: .NET solution file+- `python/uv.lock`: Locked Python dependencies++## Development Best Practices++### Before Committing Changes+**ALWAYS run these validation steps:**++**Python:**+```bash+cd python && source .venv/bin/activate+poe format # Fix formatting+poe lint # Check code quality+poe mypy # Type checking (6 minutes)+poe docs-build # Verify docs build (1+ minutes)+```++**.NET:**+```bash+cd dotnet && export PATH="$HOME/.dotnet:$PATH"+dotnet format --verify-no-changes # Check formatting+dotnet build --configuration Release --no-restore # Build (53 seconds)+dotnet test --configuration Release --filter "Category=UnitV2" --no-build # Test (25 seconds)+```++### Key Directories Reference+```+autogen/+├── python/ # Python implementation+│ ├── packages/ # Individual Python packages+│ ├── docs/ # Sphinx documentation+│ ├── samples/ # Example code+│ └── pyproject.toml # Workspace configuration+├── dotnet/ # .NET implementation+│ ├── src/ # Source projects+│ ├── test/ # Test projects+│ ├── samples/ # Sample applications+│ └── AutoGen.sln # Solution file+├── .github/workflows/ # CI/CD pipelines+└── docs/ # Additional documentation+```++This framework supports creating both simple single-agent applications and complex multi-agent workflows with support for various LLM providers, tools, and deployment patterns.\ No newline at end of filediff --git a/dotnet/dotnet-install.sh b/dotnet/dotnet-install.shnew file mode 100755index 000000000..034d2dfb1--- /dev/null+++ b/dotnet/dotnet-install.sh@@ -0,0 +1,1888 @@+#!/usr/bin/env bash+# Copyright (c) .NET Foundation and contributors. All rights reserved.+# Licensed under the MIT license. See LICENSE file in the project root for full license information.+#++# Stop script on NZEC+set -e+# Stop script if unbound variable found (use ${var:-} if intentional)+set -u+# By default cmd1 | cmd2 returns exit code of cmd2 regardless of cmd1 success+# This is causing it to fail+set -o pipefail++# Use in the the functions: eval $invocation+invocation='say_verbose "Calling: ${yellow:-}${FUNCNAME[0]} ${green:-}$*${normal:-}"'++# standard output may be used as a return value in the functions+# we need a way to write text on the screen in the functions so that+# it won't interfere with the return value.+# Exposing stream 3 as a pipe to standard output of the script itself+exec 3>&1++# Setup some colors to use. These need to work in fairly limited shells, like the Ubuntu Docker container where there are only 8 colors.+# See if stdout is a terminal+if [ -t 1 ] && command -v tput > /dev/null; then+ # see if it supports colors+ ncolors=$(tput colors || echo 0)+ if [ -n "$ncolors" ] && [ $ncolors -ge 8 ]; then+ bold="$(tput bold || echo)"+ normal="$(tput sgr0 || echo)"+ black="$(tput setaf 0 || echo)"+ red="$(tput setaf 1 || echo)"+ green="$(tput setaf 2 || echo)"+ yellow="$(tput setaf 3 || echo)"+ blue="$(tput setaf 4 || echo)"+ magenta="$(tput setaf 5 || echo)"+ cyan="$(tput setaf 6 || echo)"+ white="$(tput setaf 7 || echo)"+ fi+fi++say_warning() {+ printf "%b\n" "${yellow:-}dotnet_install: Warning: $1${normal:-}" >&3+}++say_err() {+ printf "%b\n" "${red:-}dotnet_install: Error: $1${normal:-}" >&2+}++say() {+ # using stream 3 (defined in the beginning) to not interfere with stdout of functions+ # which may be used as return value+ printf "%b\n" "${cyan:-}dotnet-install:${normal:-} $1" >&3+}++say_verbose() {+ if [ "$verbose" = true ]; then+ say "$1"+ fi+}++# This platform list is finite - if the SDK/Runtime has supported Linux distribution-specific assets,+# then and only then should the Linux distribution appear in this list.+# Adding a Linux distribution to this list does not imply distribution-specific support.+get_legacy_os_name_from_platform() {+ eval $invocation++ platform="$1"+ case "$platform" in+ "centos.7")+ echo "centos"+ return 0+ ;;+ "debian.8")+ echo "debian"+ return 0+ ;;+ "debian.9")+ echo "debian.9"+ return 0+ ;;+ "fedora.23")+ echo "fedora.23"+ return 0+ ;;+ "fedora.24")+ echo "fedora.24"+ return 0+ ;;+ "fedora.27")+ echo "fedora.27"+ return 0+ ;;+ "fedora.28")+ echo "fedora.28"+ return 0+ ;;+ "opensuse.13.2")+ echo "opensuse.13.2"+ return 0+ ;;+ "opensuse.42.1")+ echo "opensuse.42.1"+ return 0+ ;;+ "opensuse.42.3")+ echo "opensuse.42.3"+ return 0+ ;;+ "rhel.7"*)+ echo "rhel"+ return 0+ ;;+ "ubuntu.14.04")+ echo "ubuntu"+ return 0+ ;;+ "ubuntu.16.04")+ echo "ubuntu.16.04"+ return 0+ ;;+ "ubuntu.16.10")+ echo "ubuntu.16.10"+ return 0+ ;;+ "ubuntu.18.04")+ echo "ubuntu.18.04"+ return 0+ ;;+ "alpine.3.4.3")+ echo "alpine"+ return 0+ ;;+ esac+ return 1+}++get_legacy_os_name() {+ eval $invocation++ local uname=$(uname)+ if [ "$uname" = "Darwin" ]; then+ echo "osx"+ return 0+ elif [ -n "$runtime_id" ]; then+ echo $(get_legacy_os_name_from_platform "${runtime_id%-*}" || echo "${runtime_id%-*}")+ return 0+ else+ if [ -e /etc/os-release ]; then+ . /etc/os-release+ os=$(get_legacy_os_name_from_platform "$ID${VERSION_ID:+.${VERSION_ID}}" || echo "")+ if [ -n "$os" ]; then+ echo "$os"+ return 0+ fi+ fi+ fi++ say_verbose "Distribution specific OS name and version could not be detected: UName = $uname"+ return 1+}++get_linux_platform_name() {+ eval $invocation++ if [ -n "$runtime_id" ]; then+ echo "${runtime_id%-*}"+ return 0+ else+ if [ -e /etc/os-release ]; then+ . /etc/os-release+ echo "$ID${VERSION_ID:+.${VERSION_ID}}"+ return 0+ elif [ -e /etc/redhat-release ]; then+ local redhatRelease=$(</etc/redhat-release)+ if [[ $redhatRelease == "CentOS release 6."* || $redhatRelease == "Red Hat Enterprise Linux "*" release 6."* ]]; then+ echo "rhel.6"+ return 0+ fi+ fi+ fi++ say_verbose "Linux specific platform name and version could not be detected: UName = $uname"+ return 1+}++is_musl_based_distro() {+ (ldd --version 2>&1 || true) | grep -q musl+}++get_current_os_name() {+ eval $invocation++ local uname=$(uname)+ if [ "$uname" = "Darwin" ]; then+ echo "osx"+ return 0+ elif [ "$uname" = "FreeBSD" ]; then+ echo "freebsd"+ return 0+ elif [ "$uname" = "Linux" ]; then+ local linux_platform_name=""+ linux_platform_name="$(get_linux_platform_name)" || true++ if [ "$linux_platform_name" = "rhel.6" ]; then+ echo $linux_platform_name+ return 0+ elif is_musl_based_distro; then+ echo "linux-musl"+ return 0+ elif [ "$linux_platform_name" = "linux-musl" ]; then+ echo "linux-musl"+ return 0+ else+ echo "linux"+ return 0+ fi+ fi++ say_err "OS name could not be detected: UName = $uname"+ return 1+}++machine_has() {+ eval $invocation++ command -v "$1" > /dev/null 2>&1+ return $?+}++check_min_reqs() {+ local hasMinimum=false+ if machine_has "curl"; then+ hasMinimum=true+ elif machine_has "wget"; then+ hasMinimum=true+ fi++ if [ "$hasMinimum" = "false" ]; then+ say_err "curl (recommended) or wget are required to download dotnet. Install missing prerequisite to proceed."+ return 1+ fi+ return 0+}++# args:+# input - $1+to_lowercase() {+ #eval $invocation++ echo "$1" | tr '[:upper:]' '[:lower:]'+ return 0+}++# args:+# input - $1+remove_trailing_slash() {+ #eval $invocation++ local input="${1:-}"+ echo "${input%/}"+ return 0+}++# args:+# input - $1+remove_beginning_slash() {+ #eval $invocation++ local input="${1:-}"+ echo "${input#/}"+ return 0+}++# args:+# root_path - $1+# child_path - $2 - this parameter can be empty+combine_paths() {+ eval $invocation++ # TODO: Consider making it work with any number of paths. For now:+ if [ ! -z "${3:-}" ]; then+ say_err "combine_paths: Function takes two parameters."+ return 1+ fi++ local root_path="$(remove_trailing_slash "$1")"+ local child_path="$(remove_beginning_slash "${2:-}")"+ say_verbose "combine_paths: root_path=$root_path"+ say_verbose "combine_paths: child_path=$child_path"+ echo "$root_path/$child_path"+ return 0+}++get_machine_architecture() {+ eval $invocation++ if command -v uname > /dev/null; then+ CPUName=$(uname -m)+ case $CPUName in+ armv1*|armv2*|armv3*|armv4*|armv5*|armv6*)+ echo "armv6-or-below"+ return 0+ ;;+ armv*l)+ echo "arm"+ return 0+ ;;+ aarch64|arm64)+ if [ "$(getconf LONG_BIT)" -lt 64 ]; then+ # This is 32-bit OS running on 64-bit CPU (for example Raspberry Pi OS)+ echo "arm"+ return 0+ fi+ echo "arm64"+ return 0+ ;;+ s390x)+ echo "s390x"+ return 0+ ;;+ ppc64le)+ echo "ppc64le"+ return 0+ ;;+ loongarch64)+ echo "loongarch64"+ return 0+ ;;+ riscv64)+ echo "riscv64"+ return 0+ ;;+ powerpc|ppc)+ echo "ppc"+ return 0+ ;;+ esac+ fi++ # Always default to 'x64'+ echo "x64"+ return 0+}++# args:+# architecture - $1+get_normalized_architecture_from_architecture() {+ eval $invocation++ local architecture="$(to_lowercase "$1")"++ if [[ $architecture == \<auto\> ]]; then+ machine_architecture="$(get_machine_architecture)"+ if [[ "$machine_architecture" == "armv6-or-below" ]]; then+ say_err "Architecture \`$machine_architecture\` not supported. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues"+ return 1+ fi++ echo $machine_architecture+ return 0+ fi++ case "$architecture" in+ amd64|x64)+ echo "x64"+ return 0+ ;;+ arm)+ echo "arm"+ return 0+ ;;+ arm64)+ echo "arm64"+ return 0+ ;;+ s390x)+ echo "s390x"+ return 0+ ;;+ ppc64le)+ echo "ppc64le"+ return 0+ ;;+ loongarch64)+ echo "loongarch64"+ return 0+ ;;+ esac++ say_err "Architecture \`$architecture\` not supported. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues"+ return 1+}++# args:+# version - $1+# channel - $2+# architecture - $3+get_normalized_architecture_for_specific_sdk_version() {+ eval $invocation++ local is_version_support_arm64="$(is_arm64_supported "$1")"+ local is_channel_support_arm64="$(is_arm64_supported "$2")"+ local architecture="$3";+ local osname="$(get_current_os_name)"++ if [ "$osname" == "osx" ] && [ "$architecture" == "arm64" ] && { [ "$is_version_support_arm64" = false ] || [ "$is_channel_support_arm64" = false ]; }; then+ #check if rosetta is installed+ if [ "$(/usr/bin/pgrep oahd >/dev/null 2>&1;echo $?)" -eq 0 ]; then+ say_verbose "Changing user architecture from '$architecture' to 'x64' because .NET SDKs prior to version 6.0 do not support arm64."+ echo "x64"+ return 0;+ else+ say_err "Architecture \`$architecture\` is not supported for .NET SDK version \`$version\`. Please install Rosetta to allow emulation of the \`$architecture\` .NET SDK on this platform"+ return 1+ fi+ fi++ echo "$architecture"+ return 0+}++# args:+# version or channel - $1+is_arm64_supported() {+ # Extract the major version by splitting on the dot+ major_version="${1%%.*}"++ # Check if the major version is a valid number and less than 6+ case "$major_version" in+ [0-9]*)+ if [ "$major_version" -lt 6 ]; then+ echo false+ return 0+ fi+ ;;+ esac++ echo true+ return 0+}++# args:+# user_defined_os - $1+get_normalized_os() {+ eval $invocation++ local osname="$(to_lowercase "$1")"+ if [ ! -z "$osname" ]; then+ case "$osname" in+ osx | freebsd | rhel.6 | linux-musl | linux)+ echo "$osname"+ return 0+ ;;+ macos)+ osname='osx'+ echo "$osname"+ return 0+ ;;+ *)+ say_err "'$user_defined_os' is not a supported value for --os option, supported values are: osx, macos, linux, linux-musl, freebsd, rhel.6. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues."+ return 1+ ;;+ esac+ else+ osname="$(get_current_os_name)" || return 1+ fi+ echo "$osname"+ return 0+}++# args:+# quality - $1+get_normalized_quality() {+ eval $invocation++ local quality="$(to_lowercase "$1")"+ if [ ! -z "$quality" ]; then+ case "$quality" in+ daily | preview)+ echo "$quality"+ return 0+ ;;+ ga)+ #ga quality is available without specifying quality, so normalizing it to empty+ return 0+ ;;+ *)+ say_err "'$quality' is not a supported value for --quality option. Supported values are: daily, preview, ga. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues."+ return 1+ ;;+ esac+ fi+ return 0+}++# args:+# channel - $1+get_normalized_channel() {+ eval $invocation++ local channel="$(to_lowercase "$1")"++ if [[ $channel == current ]]; then+ say_warning 'Value "Current" is deprecated for -Channel option. Use "STS" instead.'+ fi++ if [[ $channel == release/* ]]; then+ say_warning 'Using branch name with -Channel option is no longer supported with newer releases. Use -Quality option with a channel in X.Y format instead.';+ fi++ if [ ! -z "$channel" ]; then+ case "$channel" in+ lts)+ echo "LTS"+ return 0+ ;;+ sts)+ echo "STS"+ return 0+ ;;+ current)+ echo "STS"+ return 0+ ;;+ *)+ echo "$channel"+ return 0+ ;;+ esac+ fi++ return 0+}++# args:+# runtime - $1+get_normalized_product() {+ eval $invocation++ local product=""+ local runtime="$(to_lowercase "$1")"+ if [[ "$runtime" == "dotnet" ]]; then+ product="dotnet-runtime"+ elif [[ "$runtime" == "aspnetcore" ]]; then+ product="aspnetcore-runtime"+ elif [ -z "$runtime" ]; then+ product="dotnet-sdk"+ fi+ echo "$product"+ return 0+}++# The version text returned from the feeds is a 1-line or 2-line string:+# For the SDK and the dotnet runtime (2 lines):+# Line 1: # commit_hash+# Line 2: # 4-part version+# For the aspnetcore runtime (1 line):+# Line 1: # 4-part version++# args:+# version_text - stdin+get_version_from_latestversion_file_content() {+ eval $invocation++ cat | tail -n 1 | sed 's/\r$//'+ return 0+}++# args:+# install_root - $1+# relative_path_to_package - $2+# specific_version - $3+is_dotnet_package_installed() {+ eval $invocation++ local install_root="$1"+ local relative_path_to_package="$2"+ local specific_version="${3//[$'\t\r\n']}"++ local dotnet_package_path="$(combine_paths "$(combine_paths "$install_root" "$relative_path_to_package")" "$specific_version")"+ say_verbose "is_dotnet_package_installed: dotnet_package_path=$dotnet_package_path"++ if [ -d "$dotnet_package_path" ]; then+ return 0+ else+ return 1+ fi+}++# args:+# downloaded file - $1+# remote_file_size - $2+validate_remote_local_file_sizes()+{+ eval $invocation++ local downloaded_file="$1"+ local remote_file_size="$2"+ local file_size=''++ if [[ "$OSTYPE" == "linux-gnu"* ]]; then+ file_size="$(stat -c '%s' "$downloaded_file")"+ elif [[ "$OSTYPE" == "darwin"* ]]; then+ # hardcode in order to avoid conflicts with GNU stat+ file_size="$(/usr/bin/stat -f '%z' "$downloaded_file")"+ fi++ if [ -n "$file_size" ]; then+ say "Downloaded file size is $file_size bytes."++ if [ -n "$remote_file_size" ] && [ -n "$file_size" ]; then+ if [ "$remote_file_size" -ne "$file_size" ]; then+ say "The remote and local file sizes are not equal. The remote file size is $remote_file_size bytes and the local size is $file_size bytes. The local package may be corrupted."+ else+ say "The remote and local file sizes are equal."+ fi+ fi++ else+ say "Either downloaded or local package size can not be measured. One of them may be corrupted."+ fi+}++# args:+# azure_feed - $1+# channel - $2+# normalized_architecture - $3+get_version_from_latestversion_file() {+ eval $invocation++ local azure_feed="$1"+ local channel="$2"+ local normalized_architecture="$3"++ local version_file_url=null+ if [[ "$runtime" == "dotnet" ]]; then+ version_file_url="$azure_feed/Runtime/$channel/latest.version"+ elif [[ "$runtime" == "aspnetcore" ]]; then+ version_file_url="$azure_feed/aspnetcore/Runtime/$channel/latest.version"+ elif [ -z "$runtime" ]; then+ version_file_url="$azure_feed/Sdk/$channel/latest.version"+ else+ say_err "Invalid value for \$runtime"+ return 1+ fi+ say_verbose "get_version_from_latestversion_file: latest url: $version_file_url"++ download "$version_file_url" || return $?+ return 0+}++# args:+# json_file - $1+parse_globaljson_file_for_version() {+ eval $invocation++ local json_file="$1"+ if [ ! -f "$json_file" ]; then+ say_err "Unable to find \`$json_file\`"+ return 1+ fi++ sdk_section=$(cat $json_file | tr -d "\r" | awk '/"sdk"/,/}/')+ if [ -z "$sdk_section" ]; then+ say_err "Unable to parse the SDK node in \`$json_file\`"+ return 1+ fi++ sdk_list=$(echo $sdk_section | awk -F"[{}]" '{print $2}')+ sdk_list=${sdk_list//[\" ]/}+ sdk_list=${sdk_list//,/$'\n'}++ local version_info=""+ while read -r line; do+ IFS=:+ while read -r key value; do+ if [[ "$key" == "version" ]]; then+ version_info=$value+ fi+ done <<< "$line"+ done <<< "$sdk_list"+ if [ -z "$version_info" ]; then+ say_err "Unable to find the SDK:version node in \`$json_file\`"+ return 1+ fi++ unset IFS;+ echo "$version_info"+ return 0+}++# args:+# azure_feed - $1+# channel - $2+# normalized_architecture - $3+# version - $4+# json_file - $5+get_specific_version_from_version() {+ eval $invocation++ local azure_feed="$1"+ local channel="$2"+ local normalized_architecture="$3"+ local version="$(to_lowercase "$4")"+ local json_file="$5"++ if [ -z "$json_file" ]; then+ if [[ "$version" == "latest" ]]; then+ local version_info+ version_info="$(get_version_from_latestversion_file "$azure_feed" "$channel" "$normalized_architecture" false)" || return 1+ say_verbose "get_specific_version_from_version: version_info=$version_info"+ echo "$version_info" | get_version_from_latestversion_file_content+ return 0+ else+ echo "$version"+ return 0+ fi+ else+ local version_info+ version_info="$(parse_globaljson_file_for_version "$json_file")" || return 1+ echo "$version_info"+ return 0+ fi+}++# args:+# azure_feed - $1+# channel - $2+# normalized_architecture - $3+# specific_version - $4+# normalized_os - $5+construct_download_link() {+ eval $invocation++ local azure_feed="$1"+ local channel="$2"+ local normalized_architecture="$3"+ local specific_version="${4//[$'\t\r\n']}"+ local specific_product_version="$(get_specific_product_version "$1" "$4")"+ local osname="$5"++ local download_link=null+ if [[ "$runtime" == "dotnet" ]]; then+ download_link="$azure_feed/Runtime/$specific_version/dotnet-runtime-$specific_product_version-$osname-$normalized_architecture.tar.gz"+ elif [[ "$runtime" == "aspnetcore" ]]; then+ download_link="$azure_feed/aspnetcore/Runtime/$specific_version/aspnetcore-runtime-$specific_product_version-$osname-$normalized_architecture.tar.gz"+ elif [ -z "$runtime" ]; then+ download_link="$azure_feed/Sdk/$specific_version/dotnet-sdk-$specific_product_version-$osname-$normalized_architecture.tar.gz"+ else+ return 1+ fi++ echo "$download_link"+ return 0+}++# args:+# azure_feed - $1+# specific_version - $2+# download link - $3 (optional)+get_specific_product_version() {+ # If we find a 'productVersion.txt' at the root of any folder, we'll use its contents+ # to resolve the version of what's in the folder, superseding the specified version.+ # if 'productVersion.txt' is missing but download link is already available, product version will be taken from download link+ eval $invocation++ local azure_feed="$1"+ local specific_version="${2//[$'\t\r\n']}"+ local package_download_link=""+ if [ $# -gt 2 ]; then+ local package_download_link="$3"+ fi+ local specific_product_version=null++ # Try to get the version number, using the productVersion.txt file located next to the installer file.+ local download_links=($(get_specific_product_version_url "$azure_feed" "$specific_version" true "$package_download_link")+ $(get_specific_product_version_url "$azure_feed" "$specific_version" false "$package_download_link"))++ for download_link in "${download_links[@]}"+ do+ say_verbose "Checking for the existence of $download_link"++ if machine_has "curl"+ then+ if ! specific_product_version=$(curl -s --fail "${download_link}${feed_credential}" 2>&1); then+ continue+ else+ echo "${specific_product_version//[$'\t\r\n']}"+ return 0+ fi++ elif machine_has "wget"+ then+ specific_product_version=$(wget -qO- "${download_link}${feed_credential}" 2>&1)+ if [ $? = 0 ]; then+ echo "${specific_product_version//[$'\t\r\n']}"+ return 0+ fi+ fi+ done++ # Getting the version number with productVersion.txt has failed. Try parsing the download link for a version number.+ say_verbose "Failed to get the version using productVersion.txt file. Download link will be parsed instead."+ specific_product_version="$(get_product_specific_version_from_download_link "$package_download_link" "$specific_version")"+ echo "${specific_product_version//[$'\t\r\n']}"+ return 0+}++# args:+# azure_feed - $1+# specific_version - $2+# is_flattened - $3+# download link - $4 (optional)+get_specific_product_version_url() {+ eval $invocation++ local azure_feed="$1"+ local specific_version="$2"+ local is_flattened="$3"+ local package_download_link=""+ if [ $# -gt 3 ]; then+ local package_download_link="$4"+ fi++ local pvFileName="productVersion.txt"+ if [ "$is_flattened" = true ]; then+ if [ -z "$runtime" ]; then+ pvFileName="sdk-productVersion.txt"+ elif [[ "$runtime" == "dotnet" ]]; then+ pvFileName="runtime-productVersion.txt"+ else+ pvFileName="$runtime-productVersion.txt"+ fi+ fi++ local download_link=null++ if [ -z "$package_download_link" ]; then+ if [[ "$runtime" == "dotnet" ]]; then+ download_link="$azure_feed/Runtime/$specific_version/${pvFileName}"+ elif [[ "$runtime" == "aspnetcore" ]]; then+ download_link="$azure_feed/aspnetcore/Runtime/$specific_version/${pvFileName}"+ elif [ -z "$runtime" ]; then+ download_link="$azure_feed/Sdk/$specific_version/${pvFileName}"+ else+ return 1+ fi+ else+ download_link="${package_download_link%/*}/${pvFileName}"+ fi++ say_verbose "Constructed productVersion link: $download_link"+ echo "$download_link"+ return 0+}++# args:+# download link - $1+# specific version - $2+get_product_specific_version_from_download_link()+{+ eval $invocation++ local download_link="$1"+ local specific_version="$2"+ local specific_product_version=""++ if [ -z "$download_link" ]; then+ echo "$specific_version"+ return 0+ fi++ #get filename+ filename="${download_link##*/}"++ #product specific version follows the product name+ #for filename 'dotnet-sdk-3.1.404-linux-x64.tar.gz': the product version is 3.1.404+ IFS='-'+ read -ra filename_elems <<< "$filename"+ count=${#filename_elems[@]}+ if [[ "$count" -gt 2 ]]; then+ specific_product_version="${filename_elems[2]}"+ else+ specific_product_version=$specific_version+ fi+ unset IFS;+ echo "$specific_product_version"+ return 0+}++# args:+# azure_feed - $1+# channel - $2+# normalized_architecture - $3+# specific_version - $4+construct_legacy_download_link() {+ eval $invocation++ local azure_feed="$1"+ local channel="$2"+ local normalized_architecture="$3"+ local specific_version="${4//[$'\t\r\n']}"++ local distro_specific_osname+ distro_specific_osname="$(get_legacy_os_name)" || return 1++ local legacy_download_link=null+ if [[ "$runtime" == "dotnet" ]]; then+ legacy_download_link="$azure_feed/Runtime/$specific_version/dotnet-$distro_specific_osname-$normalized_architecture.$specific_version.tar.gz"+ elif [ -z "$runtime" ]; then+ legacy_download_link="$azure_feed/Sdk/$specific_version/dotnet-dev-$distro_specific_osname-$normalized_architecture.$specific_version.tar.gz"+ else+ return 1+ fi++ echo "$legacy_download_link"+ return 0+}++get_user_install_path() {+ eval $invocation++ if [ ! -z "${DOTNET_INSTALL_DIR:-}" ]; then+ echo "$DOTNET_INSTALL_DIR"+ else+ echo "$HOME/.dotnet"+ fi+ return 0+}++# args:+# install_dir - $1+resolve_installation_path() {+ eval $invocation++ local install_dir=$1+ if [ "$install_dir" = "<auto>" ]; then+ local user_install_path="$(get_user_install_path)"+ say_verbose "resolve_installation_path: user_install_path=$user_install_path"+ echo "$user_install_path"+ return 0+ fi++ echo "$install_dir"+ return 0+}++# args:+# relative_or_absolute_path - $1+get_absolute_path() {+ eval $invocation++ local relative_or_absolute_path=$1+ echo "$(cd "$(dirname "$1")" && pwd -P)/$(basename "$1")"+ return 0+}++# args:+# override - $1 (boolean, true or false)+get_cp_options() {+ eval $invocation++ local override="$1"+ local override_switch=""++ if [ "$override" = false ]; then+ override_switch="-n"++ # create temporary files to check if 'cp -u' is supported+ tmp_dir="$(mktemp -d)"+ tmp_file="$tmp_dir/testfile"+ tmp_file2="$tmp_dir/testfile2"++ touch "$tmp_file"++ # use -u instead of -n if it's available+ if cp -u "$tmp_file" "$tmp_file2" 2>/dev/null; then+ override_switch="-u"+ fi++ # clean up+ rm -f "$tmp_file" "$tmp_file2"+ rm -rf "$tmp_dir"+ fi++ echo "$override_switch"+}++# args:+# input_files - stdin+# root_path - $1+# out_path - $2+# override - $3+copy_files_or_dirs_from_list() {+ eval $invocation++ local root_path="$(remove_trailing_slash "$1")"+ local out_path="$(remove_trailing_slash "$2")"+ local override="$3"+ local override_switch="$(get_cp_options "$override")"++ cat | uniq | while read -r file_path; do+ local path="$(remove_beginning_slash "${file_path#$root_path}")"+ local target="$out_path/$path"+ if [ "$override" = true ] || (! ([ -d "$target" ] || [ -e "$target" ])); then+ mkdir -p "$out_path/$(dirname "$path")"+ if [ -d "$target" ]; then+ rm -rf "$target"+ fi+ cp -R $override_switch "$root_path/$path" "$target"+ fi+ done+}++# args:+# zip_uri - $1+get_remote_file_size() {+ local zip_uri="$1"++ if machine_has "curl"; then+ file_size=$(curl -sI "$zip_uri" | grep -i content-length | awk '{ num = $2 + 0; print num }')+ elif machine_has "wget"; then+ file_size=$(wget --spider --server-response -O /dev/null "$zip_uri" 2>&1 | grep -i 'Content-Length:' | awk '{ num = $2 + 0; print num }')+ else+ say "Neither curl nor wget is available on this system."+ return+ fi++ if [ -n "$file_size" ]; then+ say "Remote file $zip_uri size is $file_size bytes."+ echo "$file_size"+ else+ say_verbose "Content-Length header was not extracted for $zip_uri."+ echo ""+ fi+}++# args:+# zip_path - $1+# out_path - $2+# remote_file_size - $3+extract_dotnet_package() {+ eval $invocation++ local zip_path="$1"+ local out_path="$2"+ local remote_file_size="$3"++ local temp_out_path="$(mktemp -d "$temporary_file_template")"++ local failed=false+ tar -xzf "$zip_path" -C "$temp_out_path" > /dev/null || failed=true++ local folders_with_version_regex='^.*/[0-9]+\.[0-9]+[^/]+/'+ find "$temp_out_path" -type f | grep -Eo "$folders_with_version_regex" | sort | copy_files_or_dirs_from_list "$temp_out_path" "$out_path" false+ find "$temp_out_path" -type f | grep -Ev "$folders_with_version_regex" | copy_files_or_dirs_from_list "$temp_out_path" "$out_path" "$override_non_versioned_files"++ validate_remote_local_file_sizes "$zip_path" "$remote_file_size"++ rm -rf "$temp_out_path"+ if [ -z ${keep_zip+x} ]; then+ rm -f "$zip_path" && say_verbose "Temporary archive file $zip_path was removed"+ fi++ if [ "$failed" = true ]; then+ say_err "Extraction failed"+ return 1+ fi+ return 0+}++# args:+# remote_path - $1+# disable_feed_credential - $2+get_http_header()+{+ eval $invocation+ local remote_path="$1"+ local disable_feed_credential="$2"++ local failed=false+ local response+ if machine_has "curl"; then+ get_http_header_curl $remote_path $disable_feed_credential || failed=true+ elif machine_has "wget"; then+ get_http_header_wget $remote_path $disable_feed_credential || failed=true+ else+ failed=true+ fi+ if [ "$failed" = true ]; then+ say_verbose "Failed to get HTTP header: '$remote_path'."+ return 1+ fi+ return 0+}++# args:+# remote_path - $1+# disable_feed_credential - $2+get_http_header_curl() {+ eval $invocation+ local remote_path="$1"+ local disable_feed_credential="$2"++ remote_path_with_credential="$remote_path"+ if [ "$disable_feed_credential" = false ]; then+ remote_path_with_credential+="$feed_credential"+ fi++ curl_options="-I -sSL --retry 5 --retry-delay 2 --connect-timeout 15 "+ curl $curl_options "$remote_path_with_credential" 2>&1 || return 1+ return 0+}++# args:+# remote_path - $1+# disable_feed_credential - $2+get_http_header_wget() {+ eval $invocation+ local remote_path="$1"+ local disable_feed_credential="$2"+ local wget_options="-q -S --spider --tries 5 "++ local wget_options_extra=''++ # Test for options that aren't supported on all wget implementations.+ if [[ $(wget -h 2>&1 | grep -E 'waitretry|connect-timeout') ]]; then+ wget_options_extra="--waitretry 2 --connect-timeout 15 "+ else+ say "wget extra options are unavailable for this environment"+ fi++ remote_path_with_credential="$remote_path"+ if [ "$disable_feed_credential" = false ]; then+ remote_path_with_credential+="$feed_credential"+ fi++ wget $wget_options $wget_options_extra "$remote_path_with_credential" 2>&1++ return $?+}++# args:+# remote_path - $1+# [out_path] - $2 - stdout if not provided+download() {+ eval $invocation++ local remote_path="$1"+ local out_path="${2:-}"++ if [[ "$remote_path" != "http"* ]]; then+ cp "$remote_path" "$out_path"+ return $?+ fi++ local failed=false+ local attempts=0+ while [ $attempts -lt 3 ]; do+ attempts=$((attempts+1))+ failed=false+ if machine_has "curl"; then+ downloadcurl "$remote_path" "$out_path" || failed=true+ elif machine_has "wget"; then+ downloadwget "$remote_path" "$out_path" || failed=true+ else+ say_err "Missing dependency: neither curl nor wget was found."+ exit 1+ fi++ if [ "$failed" = false ] || [ $attempts -ge 3 ] || { [ ! -z $http_code ] && [ $http_code = "404" ]; }; then+ break+ fi++ say "Download attempt #$attempts has failed: $http_code $download_error_msg"+ say "Attempt #$((attempts+1)) will start in $((attempts*10)) seconds."+ sleep $((attempts*10))+ done++ if [ "$failed" = true ]; then+ say_verbose "Download failed: $remote_path"+ return 1+ fi+ return 0+}++# Updates global variables $http_code and $download_error_msg+downloadcurl() {+ eval $invocation+ unset http_code+ unset download_error_msg+ local remote_path="$1"+ local out_path="${2:-}"+ # Append feed_credential as late as possible before calling curl to avoid logging feed_credential+ # Avoid passing URI with credentials to functions: note, most of them echoing parameters of invocation in verbose output.+ local remote_path_with_credential="${remote_path}${feed_credential}"+ local curl_options="--retry 20 --retry-delay 2 --connect-timeout 15 -sSL -f --create-dirs "+ local curl_exit_code=0;+ if [ -z "$out_path" ]; then+ curl_output=$(curl $curl_options "$remote_path_with_credential" 2>&1)+ curl_exit_code=$?+ echo "$curl_output"+ else+ curl_output=$(curl $curl_options -o "$out_path" "$remote_path_with_credential" 2>&1)+ curl_exit_code=$?+ fi++ # Regression in curl causes curl with --retry to return a 0 exit code even when it fails to download a file - https://github.com/curl/curl/issues/17554+ if [ $curl_exit_code -eq 0 ] && echo "$curl_output" | grep -q "^curl: ([0-9]*) "; then+ curl_exit_code=$(echo "$curl_output" | sed 's/curl: (\([0-9]*\)).*/\1/')+ fi++ if [ $curl_exit_code -gt 0 ]; then+ download_error_msg="Unable to download $remote_path."+ # Check for curl timeout codes+ if [[ $curl_exit_code == 7 || $curl_exit_code == 28 ]]; then+ download_error_msg+=" Failed to reach the server: connection timeout."+ else+ local disable_feed_credential=false+ local response=$(get_http_header_curl $remote_path $disable_feed_credential)+ http_code=$( echo "$response" | awk '/^HTTP/{print $2}' | tail -1 )+ if [[ ! -z $http_code && $http_code != 2* ]]; then+ download_error_msg+=" Returned HTTP status code: $http_code."+ fi+ fi+ say_verbose "$download_error_msg"+ return 1+ fi+ return 0+}+++# Updates global variables $http_code and $download_error_msg+downloadwget() {+ eval $invocation+ unset http_code+ unset download_error_msg+ local remote_path="$1"+ local out_path="${2:-}"+ # Append feed_credential as late as possible before calling wget to avoid logging feed_credential+ local remote_path_with_credential="${remote_path}${feed_credential}"+ local wget_options="--tries 20 "++ local wget_options_extra=''+ local wget_result=''++ # Test for options that aren't supported on all wget implementations.+ if [[ $(wget -h 2>&1 | grep -E 'waitretry|connect-timeout') ]]; then+ wget_options_extra="--waitretry 2 --connect-timeout 15 "+ else+ say "wget extra options are unavailable for this environment"+ fi++ if [ -z "$out_path" ]; then+ wget -q $wget_options $wget_options_extra -O - "$remote_path_with_credential" 2>&1+ wget_result=$?+ else+ wget $wget_options $wget_options_extra -O "$out_path" "$remote_path_with_credential" 2>&1+ wget_result=$?+ fi++ if [[ $wget_result != 0 ]]; then+ local disable_feed_credential=false+ local response=$(get_http_header_wget $remote_path $disable_feed_credential)+ http_code=$( echo "$response" | awk '/^ HTTP/{print $2}' | tail -1 )+ download_error_msg="Unable to download $remote_path."+ if [[ ! -z $http_code && $http_code != 2* ]]; then+ download_error_msg+=" Returned HTTP status code: $http_code."+ # wget exit code 4 stands for network-issue+ elif [[ $wget_result == 4 ]]; then+ download_error_msg+=" Failed to reach the server: connection timeout."+ fi+ say_verbose "$download_error_msg"+ return 1+ fi++ return 0+}++get_download_link_from_aka_ms() {+ eval $invocation++ #quality is not supported for LTS or STS channel+ #STS maps to current+ if [[ ! -z "$normalized_quality" && ("$normalized_channel" == "LTS" || "$normalized_channel" == "STS") ]]; then+ normalized_quality=""+ say_warning "Specifying quality for STS or LTS channel is not supported, the quality will be ignored."+ fi++ say_verbose "Retrieving primary payload URL from aka.ms for channel: '$normalized_channel', quality: '$normalized_quality', product: '$normalized_product', os: '$normalized_os', architecture: '$normalized_architecture'."++ #construct aka.ms link+ aka_ms_link="https://aka.ms/dotnet"+ if [ "$internal" = true ]; then+ aka_ms_link="$aka_ms_link/internal"+ fi+ aka_ms_link="$aka_ms_link/$normalized_channel"+ if [[ ! -z "$normalized_quality" ]]; then+ aka_ms_link="$aka_ms_link/$normalized_quality"+ fi+ aka_ms_link="$aka_ms_link/$normalized_product-$normalized_os-$normalized_architecture.tar.gz"+ say_verbose "Constructed aka.ms link: '$aka_ms_link'."++ #get HTTP response+ #do not pass credentials as a part of the $aka_ms_link and do not apply credentials in the get_http_header function+ #otherwise the redirect link would have credentials as well+ #it would result in applying credentials twice to the resulting link and thus breaking it, and in echoing credentials to the output as a part of redirect link+ disable_feed_credential=true+ response="$(get_http_header $aka_ms_link $disable_feed_credential)"++ say_verbose "Received response: $response"+ # Get results of all the redirects.+ http_codes=$( echo "$response" | awk '$1 ~ /^HTTP/ {print $2}' )+ # They all need to be 301, otherwise some links are broken (except for the last, which is not a redirect but 200 or 404).+ broken_redirects=$( echo "$http_codes" | sed '$d' | grep -v '301' )+ # The response may end without final code 2xx/4xx/5xx somehow, e.g. network restrictions on www.bing.com causes redirecting to bing.com fails with connection refused.+ # In this case it should not exclude the last.+ last_http_code=$( echo "$http_codes" | tail -n 1 )+ if ! [[ $last_http_code =~ ^(2|4|5)[0-9][0-9]$ ]]; then+ broken_redirects=$( echo "$http_codes" | grep -v '301' )+ fi++ # All HTTP codes are 301 (Moved Permanently), the redirect link exists.+ if [[ -z "$broken_redirects" ]]; then+ aka_ms_download_link=$( echo "$response" | awk '$1 ~ /^Location/{print $2}' | tail -1 | tr -d '\r')++ if [[ -z "$aka_ms_download_link" ]]; then+ say_verbose "The aka.ms link '$aka_ms_link' is not valid: failed to get redirect location."+ return 1+ fi++ say_verbose "The redirect location retrieved: '$aka_ms_download_link'."+ return 0+ else+ say_verbose "The aka.ms link '$aka_ms_link' is not valid: received HTTP code: $(echo "$broken_redirects" | paste -sd "," -)."+ return 1+ fi+}++get_feeds_to_use()+{+ feeds=(+ "https://builds.dotnet.microsoft.com/dotnet"+ "https://ci.dot.net/public"+ )++ if [[ -n "$azure_feed" ]]; then+ feeds=("$azure_feed")+ fi++ if [[ -n "$uncached_feed" ]]; then+ feeds=("$uncached_feed")+ fi+}++# THIS FUNCTION MAY EXIT (if the determined version is already installed).+generate_download_links() {++ download_links=()+ specific_versions=()+ effective_versions=()+ link_types=()++ # If generate_akams_links returns false, no fallback to old links. Just terminate.+ # This function may also 'exit' (if the determined version is already installed).+ generate_akams_links || return++ # Check other feeds only if we haven't been able to find an aka.ms link.+ if [[ "${#download_links[@]}" -lt 1 ]]; then+ for feed in ${feeds[@]}+ do+ # generate_regular_links may also 'exit' (if the determined version is already installed).+ generate_regular_links $feed || return+ done+ fi++ if [[ "${#download_links[@]}" -eq 0 ]]; then+ say_err "Failed to resolve the exact version number."+ return 1+ fi++ say_verbose "Generated ${#download_links[@]} links."+ for link_index in ${!download_links[@]}+ do+ say_verbose "Link $link_index: ${link_types[$link_index]}, ${effective_versions[$link_index]}, ${download_links[$link_index]}"+ done+}++# THIS FUNCTION MAY EXIT (if the determined version is already installed).+generate_akams_links() {+ local valid_aka_ms_link=true;++ normalized_version="$(to_lowercase "$version")"+ if [[ "$normalized_version" != "latest" ]] && [ -n "$normalized_quality" ]; then+ say_err "Quality and Version options are not allowed to be specified simultaneously. See https://learn.microsoft.com/dotnet/core/tools/dotnet-install-script#options for details."+ return 1+ fi++ if [[ -n "$json_file" || "$normalized_version" != "latest" ]]; then+ # aka.ms links are not needed when exact version is specified via command or json file+ return+ fi++ get_download_link_from_aka_ms || valid_aka_ms_link=false++ if [[ "$valid_aka_ms_link" == true ]]; then+ say_verbose "Retrieved primary payload URL from aka.ms link: '$aka_ms_download_link'."+ say_verbose "Downloading using legacy url will not be attempted."++ download_link=$aka_ms_download_link++ #get version from the path+ IFS='/'+ read -ra pathElems <<< "$download_link"+ count=${#pathElems[@]}+ specific_version="${pathElems[count-2]}"+ unset IFS;+ say_verbose "Version: '$specific_version'."++ #Retrieve effective version+ effective_version="$(get_specific_product_version "$azure_feed" "$specific_version" "$download_link")"++ # Add link info to arrays+ download_links+=($download_link)+ specific_versions+=($specific_version)+ effective_versions+=($effective_version)+ link_types+=("aka.ms")++ # Check if the SDK version is already installed.+ if [[ "$dry_run" != true ]] && is_dotnet_package_installed "$install_root" "$asset_relative_path" "$effective_version"; then+ say "$asset_name with version '$effective_version' is already installed."+ exit 0+ fi++ return 0+ fi++ # if quality is specified - exit with error - there is no fallback approach+ if [ ! -z "$normalized_quality" ]; then+ say_err "Failed to locate the latest version in the channel '$normalized_channel' with '$normalized_quality' quality for '$normalized_product', os: '$normalized_os', architecture: '$normalized_architecture'."+ say_err "Refer to: https://aka.ms/dotnet-os-lifecycle for information on .NET Core support."+ return 1+ fi+ say_verbose "Falling back to latest.version file approach."+}++# THIS FUNCTION MAY EXIT (if the determined version is already installed)+# args:+# feed - $1+generate_regular_links() {+ local feed="$1"+ local valid_legacy_download_link=true++ specific_version=$(get_specific_version_from_version "$feed" "$channel" "$normalized_architecture" "$version" "$json_file") || specific_version='0'++ if [[ "$specific_version" == '0' ]]; then+ say_verbose "Failed to resolve the specific version number using feed '$feed'"+ return+ fi++ effective_version="$(get_specific_product_version "$feed" "$specific_version")"+ say_verbose "specific_version=$specific_version"++ download_link="$(construct_download_link "$feed" "$channel" "$normalized_architecture" "$specific_version" "$normalized_os")"+ say_verbose "Constructed primary named payload URL: $download_link"++ # Add link info to arrays+ download_links+=($download_link)+ specific_versions+=($specific_version)+ effective_versions+=($effective_version)+ link_types+=("primary")++ legacy_download_link="$(construct_legacy_download_link "$feed" "$channel" "$normalized_architecture" "$specific_version")" || valid_legacy_download_link=false++ if [ "$valid_legacy_download_link" = true ]; then+ say_verbose "Constructed legacy named payload URL: $legacy_download_link"++ download_links+=($legacy_download_link)+ specific_versions+=($specific_version)+ effective_versions+=($effective_version)+ link_types+=("legacy")+ else+ legacy_download_link=""+ say_verbose "Could not construct a legacy_download_link; omitting..."+ fi++ # Check if the SDK version is already installed.+ if [[ "$dry_run" != true ]] && is_dotnet_package_installed "$install_root" "$asset_relative_path" "$effective_version"; then+ say "$asset_name with version '$effective_version' is already installed."+ exit 0+ fi+}++print_dry_run() {++ say "Payload URLs:"++ for link_index in "${!download_links[@]}"+ do+ say "URL #$link_index - ${link_types[$link_index]}: ${download_links[$link_index]}"+ done++ resolved_version=${specific_versions[0]}+ repeatable_command="./$script_name --version "\""$resolved_version"\"" --install-dir "\""$install_root"\"" --architecture "\""$normalized_architecture"\"" --os "\""$normalized_os"\"""++ if [ ! -z "$normalized_quality" ]; then+ repeatable_command+=" --quality "\""$normalized_quality"\"""+ fi++ if [[ "$runtime" == "dotnet" ]]; then+ repeatable_command+=" --runtime "\""dotnet"\"""+ elif [[ "$runtime" == "aspnetcore" ]]; then+ repeatable_command+=" --runtime "\""aspnetcore"\"""+ fi++ repeatable_command+="$non_dynamic_parameters"++ if [ -n "$feed_credential" ]; then+ repeatable_command+=" --feed-credential "\""<feed_credential>"\"""+ fi++ say "Repeatable invocation: $repeatable_command"+}++calculate_vars() {+ eval $invocation++ script_name=$(basename "$0")+ normalized_architecture="$(get_normalized_architecture_from_architecture "$architecture")"+ say_verbose "Normalized architecture: '$normalized_architecture'."+ normalized_os="$(get_normalized_os "$user_defined_os")"+ say_verbose "Normalized OS: '$normalized_os'."+ normalized_quality="$(get_normalized_quality "$quality")"+ say_verbose "Normalized quality: '$normalized_quality'."+ normalized_channel="$(get_normalized_channel "$channel")"+ say_verbose "Normalized channel: '$normalized_channel'."+ normalized_product="$(get_normalized_product "$runtime")"+ say_verbose "Normalized product: '$normalized_product'."+ install_root="$(resolve_installation_path "$install_dir")"+ say_verbose "InstallRoot: '$install_root'."++ normalized_architecture="$(get_normalized_architecture_for_specific_sdk_version "$version" "$normalized_channel" "$normalized_architecture")"++ if [[ "$runtime" == "dotnet" ]]; then+ asset_relative_path="shared/Microsoft.NETCore.App"+ asset_name=".NET Core Runtime"+ elif [[ "$runtime" == "aspnetcore" ]]; then+ asset_relative_path="shared/Microsoft.AspNetCore.App"+ asset_name="ASP.NET Core Runtime"+ elif [ -z "$runtime" ]; then+ asset_relative_path="sdk"+ asset_name=".NET Core SDK"+ fi++ get_feeds_to_use+}++install_dotnet() {+ eval $invocation+ local download_failed=false+ local download_completed=false+ local remote_file_size=0++ mkdir -p "$install_root"+ zip_path="${zip_path:-$(mktemp "$temporary_file_template")}"+ say_verbose "Archive path: $zip_path"++ for link_index in "${!download_links[@]}"+ do+ download_link="${download_links[$link_index]}"+ specific_version="${specific_versions[$link_index]}"+ effective_version="${effective_versions[$link_index]}"+ link_type="${link_types[$link_index]}"++ say "Attempting to download using $link_type link $download_link"++ # The download function will set variables $http_code and $download_error_msg in case of failure.+ download_failed=false+ download "$download_link" "$zip_path" 2>&1 || download_failed=true++ if [ "$download_failed" = true ]; then+ case $http_code in+ 404)+ say "The resource at $link_type link '$download_link' is not available."+ ;;+ *)+ say "Failed to download $link_type link '$download_link': $http_code $download_error_msg"+ ;;+ esac+ rm -f "$zip_path" 2>&1 && say_verbose "Temporary archive file $zip_path was removed"+ else+ download_completed=true+ break+ fi+ done++ if [[ "$download_completed" == false ]]; then+ say_err "Could not find \`$asset_name\` with version = $specific_version"+ say_err "Refer to: https://aka.ms/dotnet-os-lifecycle for information on .NET Core support"+ return 1+ fi++ remote_file_size="$(get_remote_file_size "$download_link")"++ say "Extracting archive from $download_link"+ extract_dotnet_package "$zip_path" "$install_root" "$remote_file_size" || return 1++ # Check if the SDK version is installed; if not, fail the installation.+ # if the version contains "RTM" or "servicing"; check if a 'release-type' SDK version is installed.+ if [[ $specific_version == *"rtm"* || $specific_version == *"servicing"* ]]; then+ IFS='-'+ read -ra verArr <<< "$specific_version"+ release_version="${verArr[0]}"+ unset IFS;+ say_verbose "Checking installation: version = $release_version"+ if is_dotnet_package_installed "$install_root" "$asset_relative_path" "$release_version"; then+ say "Installed version is $effective_version"+ return 0+ fi+ fi++ # Check if the standard SDK version is installed.+ say_verbose "Checking installation: version = $effective_version"+ if is_dotnet_package_installed "$install_root" "$asset_relative_path" "$effective_version"; then+ say "Installed version is $effective_version"+ return 0+ fi++ # Version verification failed. More likely something is wrong either with the downloaded content or with the verification algorithm.+ say_err "Failed to verify the version of installed \`$asset_name\`.\nInstallation source: $download_link.\nInstallation location: $install_root.\nReport the bug at https://github.com/dotnet/install-scripts/issues."+ say_err "\`$asset_name\` with version = $effective_version failed to install with an error."+ return 1+}++args=("$@")++local_version_file_relative_path="/.version"+bin_folder_relative_path=""+temporary_file_template="${TMPDIR:-/tmp}/dotnet.XXXXXXXXX"++channel="LTS"+version="Latest"+json_file=""+install_dir="<auto>"+architecture="<auto>"+dry_run=false+no_path=false+azure_feed=""+uncached_feed=""+feed_credential=""+verbose=false+runtime=""+runtime_id=""+quality=""+internal=false+override_non_versioned_files=true+non_dynamic_parameters=""+user_defined_os=""++while [ $# -ne 0 ]+do+ name="$1"+ case "$name" in+ -c|--channel|-[Cc]hannel)+ shift+ channel="$1"+ ;;+ -v|--version|-[Vv]ersion)+ shift+ version="$1"+ ;;+ -q|--quality|-[Qq]uality)+ shift+ quality="$1"+ ;;+ --internal|-[Ii]nternal)+ internal=true+ non_dynamic_parameters+=" $name"+ ;;+ -i|--install-dir|-[Ii]nstall[Dd]ir)+ shift+ install_dir="$1"+ ;;+ --arch|--architecture|-[Aa]rch|-[Aa]rchitecture)+ shift+ architecture="$1"+ ;;+ --os|-[Oo][SS])+ shift+ user_defined_os="$1"+ ;;+ --shared-runtime|-[Ss]hared[Rr]untime)+ say_warning "The --shared-runtime flag is obsolete and may be removed in a future version of this script. The recommended usage is to specify '--runtime dotnet'."+ if [ -z "$runtime" ]; then+ runtime="dotnet"+ fi+ ;;+ --runtime|-[Rr]untime)+ shift+ runtime="$1"+ if [[ "$runtime" != "dotnet" ]] && [[ "$runtime" != "aspnetcore" ]]; then+ say_err "Unsupported value for --runtime: '$1'. Valid values are 'dotnet' and 'aspnetcore'."+ if [[ "$runtime" == "windowsdesktop" ]]; then+ say_err "WindowsDesktop archives are manufactured for Windows platforms only."+ fi+ exit 1+ fi+ ;;+ --dry-run|-[Dd]ry[Rr]un)+ dry_run=true+ ;;+ --no-path|-[Nn]o[Pp]ath)+ no_path=true+ non_dynamic_parameters+=" $name"+ ;;+ --verbose|-[Vv]erbose)+ verbose=true+ non_dynamic_parameters+=" $name"+ ;;+ --azure-feed|-[Aa]zure[Ff]eed)+ shift+ azure_feed="$1"+ non_dynamic_parameters+=" $name "\""$1"\"""+ ;;+ --uncached-feed|-[Uu]ncached[Ff]eed)+ shift+ uncached_feed="$1"+ non_dynamic_parameters+=" $name "\""$1"\"""+ ;;+ --feed-credential|-[Ff]eed[Cc]redential)+ shift+ feed_credential="$1"+ #feed_credential should start with "?", for it to be added to the end of the link.+ #adding "?" at the beginning of the feed_credential if needed.+ [[ -z "$(echo $feed_credential)" ]] || [[ $feed_credential == \?* ]] || feed_credential="?$feed_credential"+ ;;+ --runtime-id|-[Rr]untime[Ii]d)+ shift+ runtime_id="$1"+ non_dynamic_parameters+=" $name "\""$1"\"""+ say_warning "Use of --runtime-id is obsolete and should be limited to the versions below 2.1. To override architecture, use --architecture option instead. To override OS, use --os option instead."+ ;;+ --jsonfile|-[Jj][Ss]on[Ff]ile)+ shift+ json_file="$1"+ ;;+ --skip-non-versioned-files|-[Ss]kip[Nn]on[Vv]ersioned[Ff]iles)+ override_non_versioned_files=false+ non_dynamic_parameters+=" $name"+ ;;+ --keep-zip|-[Kk]eep[Zz]ip)+ keep_zip=true+ non_dynamic_parameters+=" $name"+ ;;+ --zip-path|-[Zz]ip[Pp]ath)+ shift+ zip_path="$1"+ ;;+ -?|--?|-h|--help|-[Hh]elp)+ script_name="dotnet-install.sh"+ echo ".NET Tools Installer"+ echo "Usage:"+ echo " # Install a .NET SDK of a given Quality from a given Channel"+ echo " $script_name [-c|--channel <CHANNEL>] [-q|--quality <QUALITY>]"+ echo " # Install a .NET SDK of a specific public version"+ echo " $script_name [-v|--version <VERSION>]"+ echo " $script_name -h|-?|--help"+ echo ""+ echo "$script_name is a simple command line interface for obtaining dotnet cli."+ echo " Note that the intended use of this script is for Continuous Integration (CI) scenarios, where:"+ echo " - The SDK needs to be installed without user interaction and without admin rights."+ echo " - The SDK installation doesn't need to persist across multiple CI runs."+ echo " To set up a development environment or to run apps, use installers rather than this script. Visit https://dotnet.microsoft.com/download to get the installer."+ echo ""+ echo "Options:"+ echo " -c,--channel <CHANNEL> Download from the channel specified, Defaults to \`$channel\`."+ echo " -Channel"+ echo " Possible values:"+ echo " - STS - the most recent Standard Term Support release"+ echo " - LTS - the most recent Long Term Support release"+ echo " - 2-part version in a format A.B - represents a specific release"+ echo " examples: 2.0; 1.0"+ echo " - 3-part version in a format A.B.Cxx - represents a specific SDK release"+ echo " examples: 5.0.1xx, 5.0.2xx."+ echo " Supported since 5.0 release"+ echo " Warning: Value 'Current' is deprecated for the Channel parameter. Use 'STS' instead."+ echo " Note: The version parameter overrides the channel parameter when any version other than 'latest' is used."+ echo " -v,--version <VERSION> Use specific VERSION, Defaults to \`$version\`."+ echo " -Version"+ echo " Possible values:"+ echo " - latest - the latest build on specific channel"+ echo " - 3-part version in a format A.B.C - represents specific version of build"+ echo " examples: 2.0.0-preview2-006120; 1.1.0"+ echo " -q,--quality <quality> Download the latest build of specified quality in the channel."+ echo " -Quality"+ echo " The possible values are: daily, preview, GA."+ echo " Works only in combination with channel. Not applicable for STS and LTS channels and will be ignored if those channels are used."+ echo " For SDK use channel in A.B.Cxx format. Using quality for SDK together with channel in A.B format is not supported."+ echo " Supported since 5.0 release."+ echo " Note: The version parameter overrides the channel parameter when any version other than 'latest' is used, and therefore overrides the quality."+ echo " --internal,-Internal Download internal builds. Requires providing credentials via --feed-credential parameter."+ echo " --feed-credential <FEEDCREDENTIAL> Token to access Azure feed. Used as a query string to append to the Azure feed."+ echo " -FeedCredential This parameter typically is not specified."+ echo " -i,--install-dir <DIR> Install under specified location (see Install Location below)"+ echo " -InstallDir"+ echo " --architecture <ARCHITECTURE> Architecture of dotnet binaries to be installed, Defaults to \`$architecture\`."+ echo " --arch,-Architecture,-Arch"+ echo " Possible values: x64, arm, arm64, s390x, ppc64le and loongarch64"+ echo " --os <system> Specifies operating system to be used when selecting the installer."+ echo " Overrides the OS determination approach used by the script. Supported values: osx, linux, linux-musl, freebsd, rhel.6."+ echo " In case any other value is provided, the platform will be determined by the script based on machine configuration."+ echo " Not supported for legacy links. Use --runtime-id to specify platform for legacy links."+ echo " Refer to: https://aka.ms/dotnet-os-lifecycle for more information."+ echo " --runtime <RUNTIME> Installs a shared runtime only, without the SDK."+ echo " -Runtime"+ echo " Possible values:"+ echo " - dotnet - the Microsoft.NETCore.App shared runtime"+ echo " - aspnetcore - the Microsoft.AspNetCore.App shared runtime"+ echo " --dry-run,-DryRun Do not perform installation. Display download link."+ echo " --no-path, -NoPath Do not set PATH for the current process."+ echo " --verbose,-Verbose Display diagnostics information."+ echo " --azure-feed,-AzureFeed For internal use only."+ echo " Allows using a different storage to download SDK archives from."+ echo " --uncached-feed,-UncachedFeed For internal use only."+ echo " Allows using a different storage to download SDK archives from."+ echo " --skip-non-versioned-files Skips non-versioned files if they already exist, such as the dotnet executable."+ echo " -SkipNonVersionedFiles"+ echo " --jsonfile <JSONFILE> Determines the SDK version from a user specified global.json file."+ echo " Note: global.json must have a value for 'SDK:Version'"+ echo " --keep-zip,-KeepZip If set, downloaded file is kept."+ echo " --zip-path, -ZipPath If set, downloaded file is stored at the specified path."+ echo " -?,--?,-h,--help,-Help Shows this help message"+ echo ""+ echo "Install Location:"+ echo " Location is chosen in following order:"+ echo " - --install-dir option"+ echo " - Environmental variable DOTNET_INSTALL_DIR"+ echo " - $HOME/.dotnet"+ exit 0+ ;;+ *)+ say_err "Unknown argument \`$name\`"+ exit 1+ ;;+ esac++ shift+done++say_verbose "Note that the intended use of this script is for Continuous Integration (CI) scenarios, where:"+say_verbose "- The SDK needs to be installed without user interaction and without admin rights."+say_verbose "- The SDK installation doesn't need to persist across multiple CI runs."+say_verbose "To set up a development environment or to run apps, use installers rather than this script. Visit https://dotnet.microsoft.com/download to get the installer.\n"++if [ "$internal" = true ] && [ -z "$(echo $feed_credential)" ]; then+ message="Provide credentials via --feed-credential parameter."+ if [ "$dry_run" = true ]; then+ say_warning "$message"+ else+ say_err "$message"+ exit 1+ fi+fi++check_min_reqs+calculate_vars+# generate_regular_links call below will 'exit' if the determined version is already installed.+generate_download_links++if [[ "$dry_run" = true ]]; then+ print_dry_run+ exit 0+fi++install_dotnet++bin_path="$(get_absolute_path "$(combine_paths "$install_root" "$bin_folder_relative_path")")"+if [ "$no_path" = false ]; then+ say "Adding to current process PATH: \`$bin_path\`. Note: This change will be visible only when sourcing script."+ export PATH="$bin_path":"$PATH"+else+ say "Binaries of dotnet can be found in $bin_path"+fi++say "Note that the script does not resolve dependencies during installation."+say "To check the list of dependencies, go to https://learn.microsoft.com/dotnet/core/install, select your operating system and check the \"Dependencies\" section."+say "Installation finished successfully."