Veeam Update Repository Mirror on IIS for VSA/VIA (Windows Veeam ONE server)

<#
.SYNOPSIS
  Fetch the entire content (recursively) from https://repository.veeam.com/vsa/
  and zip it after download.

.DESCRIPTION
  - Preserves folder structure locally.
  - Skips files that have already been downloaded with the same size.
  - Retries on temporary network errors.
  - Zips the full local copy into a single .zip at the end.

.PARAMETER BaseUrl
  Root URL of the Veeam update repository (default: https://repository.veeam.com/vsa/)

.PARAMETER OutRoot
  Local root folder for download (default: D:\inetpub\veeamrepo\vsa)

.PARAMETER ZipPath
  Location of the zip file after sync (default: D:\Downloads\veeam-vsa.zip)

.PARAMETER MaxRetries
  Number of attempts on error (default: 3)
#>

[CmdletBinding()]
param(
  [string]$BaseUrl   = "https://repository.veeam.com/vsa/",
  [string]$OutRoot   = "D:\inetpub\veeamrepo\vsa",
  [string]$ZipPath   = "D:\Downloads\veeam-vsa.zip",
  [int]$MaxRetries   = 3
)

# Ensure TLS 1.2 for any HTTPS redirect
 try {
   [System.Net.ServicePointManager]::SecurityProtocol = `
     [System.Net.SecurityProtocolType]::Tls12 `
     -bor [System.Net.SecurityProtocolType]::Tls11 `
     -bor [System.Net.SecurityProtocolType]::Tls
 } catch { }

# Use a fixed User-Agent so directory listing isn't denied
$Global:DefaultHeaders = @{
  "User-Agent" = "PowerShell/7 (Sync-VeeamVAS)"
}

# Helper: Create absolute URI from base + relative
function Join-Uri {
  param(
    [Parameter(Mandatory=$true)][string]$Base,
    [Parameter(Mandatory=$true)][string]$Href
  )
  $baseUri = [System.Uri]$Base
  # Handle absolute, root-relative, and relative
  if ($Href -match '^(http|https)://') {
    return $Href
  } elseif ($Href.StartsWith('/')) {
    return ($baseUri.Scheme + "://" + $baseUri.Host + $Href)
  } else {
    return ([System.Uri]$baseUri, $Href -join '')
  }
}

# Decode percent-encoded characters (e.g. %2B -> +) for safe local filesystem naming.
# IMPORTANT: only applied to the LOCAL file/folder name, never to the URL used for the
# actual HTTP request -- IIS/HTTP.sys expects the request to keep its original encoding.
function Get-DecodedLocalName {
  param([Parameter(Mandatory=$true)][string]$EncodedName)
  return [System.Uri]::UnescapeDataString($EncodedName)
}

# Fetch and parse directory listing into files and folders
function Get-DirectoryItems {
  param([Parameter(Mandatory=$true)][string]$Url)

  Write-Verbose "Fetching listing: $Url"

  $resp = Invoke-WebRequest -Uri $Url -Headers $Global:DefaultHeaders -ErrorAction Stop -MaximumRedirection 10

  $content = $resp.Content


  # Simpler and robust: match only href attributes, not the full <a> tag structure.
  # Note: Use the RegexOptions enum, NOT a string.
  $hrefMatches = [System.Text.RegularExpressions.Regex]::Matches(
    $content,
    'href\s*=\s*"([^"]+)"',
    [System.Text.RegularExpressions.RegexOptions]::IgnoreCase
  )

  $items = @()
  foreach ($m in $hrefMatches) {
    $href = $m.Groups[1].Value

    # Exclude parent, sorting, and fragments
    if ($href -eq "../" -or $href.StartsWith("?") -or $href.StartsWith("#")) { continue }

    $abs = Join-Uri -Base $Url -Href $href

    if ($href.EndsWith('/')) {
      # Folder name = last segment without trailing slash
      $rawName = ($href.TrimEnd('/') -split '/')[-1]
      if ([string]::IsNullOrWhiteSpace($rawName)) { $rawName = $href.TrimEnd('/') }
      $name = Get-DecodedLocalName -EncodedName $rawName
      $items += [pscustomobject]@{ Type="Directory"; Name=$name; Url=$abs }
    } else {
      # File name = last segment
      $rawName = ($href -split '/')[-1]
      # Exclude plain listing files
      if ($rawName -match '^index\.(html?|htm)$') { continue }
      $name = Get-DecodedLocalName -EncodedName $rawName
      $items += [pscustomobject]@{ Type="File"; Name=$name; Url=$abs }
    }
  }

  return $items
}

# HEAD to get Content-Length (may be missing on some endpoints)

function Get-RemoteContentLength {
  param([Parameter(Mandatory=$true)][string]$Url)

  # 1) Try HEAD first
  try {
    $head = Invoke-WebRequest -Uri $Url -Method Head -Headers $Global:DefaultHeaders -ErrorAction Stop

    if ($head -and $head.Headers) {
      $clVals = $head.Headers['Content-Length']     # string or string[]
      $clStr  = $null

      if ($clVals -is [string]) {
        $clStr = $clVals
      } elseif ($clVals -is [System.Array]) {
        if ($clVals.Length -gt 0) { $clStr = $clVals[0] }
      }

      if ($clStr -and ($clStr -match '^\d+$')) {
        return [int64]$clStr
      }
    }
  } catch {
    # ignore and fall back
  }

  # 2) Fallback: GET a single byte and parse Content-Range (e.g., "bytes 0-0/123456")
  try {
    # Clone headers and add Range (and optionally disable compression)
    $rangeHeaders = @{}
    foreach ($kv in $Global:DefaultHeaders.GetEnumerator()) { $rangeHeaders[$kv.Key] = $kv.Value }
    $rangeHeaders['Range'] = 'bytes=0-0'
    # $rangeHeaders['Accept-Encoding'] = 'identity'   # optional

    $resp = Invoke-WebRequest -Uri $Url -Method Get -Headers $rangeHeaders -ErrorAction Stop

    if ($resp -and $resp.Headers) {
      $crVals = $resp.Headers['Content-Range']       # string or string[]
      $crStr  = $null
      if ($crVals -is [string]) {
        $crStr = $crVals
      } elseif ($crVals -is [System.Array]) {
        if ($crVals.Length -gt 0) { $crStr = $crVals[0] }
      }

      if ($crStr -and ($crStr -match '/(\d+)$')) {
        return [int64]$Matches[1]
      }
    }
  } catch {
       # Range not supported or server rejects: return $null
  }

  return $null
}

# Download with retry and skip if local file has identical size
function Download-File {
  param(
    [Parameter(Mandatory=$true)][string]$Url,
    [Parameter(Mandatory=$true)][string]$OutFile,
    [int]$MaxRetries = 3
  )
  $remoteLen = Get-RemoteContentLength -Url $Url
  $dir = Split-Path -Path $OutFile -Parent
  if (-not (Test-Path -LiteralPath $dir)) {
    New-Item -ItemType Directory -Path $dir -Force | Out-Null
  }

  if (Test-Path -LiteralPath $OutFile -PathType Leaf) {
    try {
      $localLen = (Get-Item -LiteralPath $OutFile).Length
      if ($remoteLen -ne $null -and $localLen -eq $remoteLen) {
        Write-Host "SKIP (match size)  $Url -> $OutFile  ($localLen bytes)"
        return
      }
    } catch { }
  }

  $attempt = 0
  while ($attempt -lt $MaxRetries) {
    $attempt++
    try {
      Write-Host "Downloading [$attempt/$MaxRetries] $Url"
      Invoke-WebRequest -Uri $Url -Headers $Global:DefaultHeaders -OutFile $OutFile -ErrorAction Stop
      # Validate size if we know remoteLen
      if ($remoteLen -ne $null) {
        $localLen = (Get-Item -LiteralPath $OutFile).Length
        if ($localLen -ne $remoteLen) {
          throw "Size mismatch: local=$localLen, remote=$remoteLen"
        }
      }
      return
    } catch {
      Write-Warning "Download error ($Url): $($_.Exception.Message)"
      Start-Sleep -Seconds ([math]::Min(15, 3 * $attempt))
      if ($attempt -ge $MaxRetries) {
        Write-Error "Giving up after $MaxRetries attempts: $Url"
      }
    }
  }
}

# Recursively sync from URL to local folder
function Sync-Url {
  param(
    [Parameter(Mandatory=$true)][string]$Url,
    [Parameter(Mandatory=$true)][string]$LocalRoot
  )
  if (-not (Test-Path -LiteralPath $LocalRoot)) {
    New-Item -ItemType Directory -Path $LocalRoot -Force | Out-Null
  }

  $items = Get-DirectoryItems -Url $Url

  # Folders first, then files
  foreach ($d in $items | Where-Object { $_.Type -eq "Directory" }) {
    $subLocal = Join-Path -Path $LocalRoot -ChildPath $d.Name
    Write-Host "==> Folder: $($d.Url)  ->  $subLocal"
    Sync-Url -Url $d.Url -LocalRoot $subLocal
  }
  foreach ($f in $items | Where-Object { $_.Type -eq "File" }) {
    $outFile = Join-Path -Path $LocalRoot -ChildPath $f.Name
    Download-File -Url $f.Url -OutFile $outFile -MaxRetries $MaxRetries
  }
}

# ==== Execution ====
Write-Host "Starting sync from: $BaseUrl"
Write-Host "Local root folder:  $OutRoot"
Sync-Url -Url $BaseUrl -LocalRoot $OutRoot

# === Verify no percent-encoded names remain locally ===
Write-Host "`nVerifying no percent-encoded characters remain in local file/folder names..."
$stillEncoded = Get-ChildItem -Path $OutRoot -Recurse -Force |
    Where-Object { $_.Name -match '%[0-9A-Fa-f]{2}' }

if ($stillEncoded) {
    Write-Warning "Found $($stillEncoded.Count) item(s) still containing percent-encoding (needs manual review):"
    $stillEncoded | Select-Object FullName | Format-Table -AutoSize
} else {
    Write-Host "Clean -- no percent-encoded names found." -ForegroundColor Green
}

# === Zip (user interaction) ===
$caption = "Create ZIP"
$message = "Do you want to create a new zip file at `"$ZipPath`" from `"$OutRoot`"?"
$choices = [System.Management.Automation.Host.ChoiceDescription[]]@(
    (New-Object System.Management.Automation.Host.ChoiceDescription '&Yes', 'Create or overwrite the zip file.'),
    (New-Object System.Management.Automation.Host.ChoiceDescription '&No',  'Skip creating the zip file.')
)

# Default choice: No (index 1)
$decision = $Host.UI.PromptForChoice($caption, $message, $choices, 1)

if ($decision -eq 0) {
    Write-Host "Preparing to compress: $OutRoot -> $ZipPath"
    try {
        $doCompress = $true
        if (Test-Path -LiteralPath $ZipPath) {
            $overwriteCaption = "Overwrite existing ZIP?"
            $overwriteMessage = "A zip file already exists at `"$ZipPath`". Do you want to overwrite it?"
            $overwriteChoices = [System.Management.Automation.Host.ChoiceDescription[]]@(
                (New-Object System.Management.Automation.Host.ChoiceDescription '&Yes', 'Overwrite the existing zip file.'),
                (New-Object System.Management.Automation.Host.ChoiceDescription '&No',  'Keep the existing zip and skip compression.')
            )
            # Default: No (index 1)
            $overwriteDecision = $Host.UI.PromptForChoice($overwriteCaption, $overwriteMessage, $overwriteChoices, 1)

            if ($overwriteDecision -ne 0) {
                Write-Host "Skipping compression: existing zip kept."
                # Exit the zip step but continue the script
                $doCompress = $false
            } else {
                # Remove existing zip so Compress-Archive can create a fresh one
                Remove-Item -LiteralPath $ZipPath -Force
            }
        }
        if ($doCompress) {
            Compress-Archive -Path $OutRoot -DestinationPath $ZipPath -Force
            Write-Host "ZIP created: $ZipPath"
        }

    } catch {
        Write-Error "Could not compress: $($_.Exception.Message)"
    }
} else {
    Write-Host "Skipping compression per user choice."
}