DRAFT Add OPC UA data channels and the opc.quic transport

.azurepipelines/expected-packages.txt

@@ -11,6 +11,10 @@
 # `dotnet pack` output only; the hand-authored `nuget/*.nuspec` packages are packed
 # in a later pipeline step and are not part of this check.
 #
+# Native QUIC/HTTP3 packages are validated and produced by the dedicated native
+# workflow; they require native build receipts and are not part of signed preview
+# package publication.
+#
 # To update: run `dotnet pack preview-pack.slnx` and reconcile the produced
 # package ids with this file in the same pull request that changes them.
 
@@ -25,6 +29,8 @@ OPCFoundation.NetStandard.Opc.Ua.AutoID
 OPCFoundation.NetStandard.Opc.Ua.AutoID.Client
 OPCFoundation.NetStandard.Opc.Ua.AutoID.Server
 OPCFoundation.NetStandard.Opc.Ua.Bindings.Https
+OPCFoundation.NetStandard.Opc.Ua.Bindings.Quic
+OPCFoundation.NetStandard.Opc.Ua.Bindings.WebTransport
 OPCFoundation.NetStandard.Opc.Ua.Client
 OPCFoundation.NetStandard.Opc.Ua.Client.ComplexTypes
 OPCFoundation.NetStandard.Opc.Ua.Configuration

.gitattributes

@@ -32,7 +32,8 @@ src/Opc.Ua.AMB/Model/Opc.Ua.AMB.NodeSet2.xml text eol=lf
 # SHA-256 hashes are pinned in src/Opc.Ua.AutoID/Model/provenance.json and
 # tests/Opc.Ua.AutoID.Tests/AutoIdModelAssetTests.cs, so the checked-out bytes must be
 # the upstream bytes on every platform.
-src/Opc.Ua.AutoID/Model/Opc.Ua.AutoID.NodeSet2.xml text eol=lf
+# The upstream license banner includes trailing spaces covered by the pinned hash.
+src/Opc.Ua.AutoID/Model/Opc.Ua.AutoID.NodeSet2.xml text eol=lf whitespace=-blank-at-eol
 src/Opc.Ua.AutoID/Model/Opc.Ua.AutoID.NodeIds.csv text eol=lf
 
 # Denote all files that should not have line endings normalized, should not be

.github/actions/run-dotnet-tests/action.yml

@@ -40,6 +40,10 @@ inputs:
     description: Collect Cobertura coverage ('true' or 'false').
     required: false
     default: 'false'
+  require-clean-exit:
+    description: Reject non-zero test-host exits even when the recorded counters all pass.
+    required: false
+    default: 'false'
   artifact-name:
     description: Name of the artifact that receives the results of this batch.
     required: true
@@ -223,6 +227,7 @@ runs:
       CI_HANG_TIMEOUT: ${{ inputs.hang-timeout }}
       CI_PER_PROJECT_TIMEOUT: ${{ inputs.per-project-timeout }}
       CI_COVERAGE: ${{ inputs.coverage }}
+      CI_REQUIRE_CLEAN_EXIT: ${{ inputs.require-clean-exit }}
     run: |
       # The core_pattern set by 'Enable native core dumps' only takes effect for
       # a process whose RLIMIT_CORE is non-zero, and the limit is inherited, not
@@ -249,6 +254,7 @@ runs:
         -HangTimeout $env:CI_HANG_TIMEOUT `
         -PerProjectTimeoutMinutes ([int]$env:CI_PER_PROJECT_TIMEOUT) `
         -ResultsDirectory 'TestResults' `
+        -RequireCleanExit:($env:CI_REQUIRE_CLEAN_EXIT -eq 'true') `
         -Coverage:($env:CI_COVERAGE -eq 'true')
 
   # Apple Crash Reporter writes .crash (legacy) and .ips (JSON, macOS 12+)

.github/scripts/get-ci-matrix.ps1

@@ -149,11 +149,20 @@ $DefaultFilter = 'TestCategory!=LongRunning&TestCategory!=Stress'
 #                           validates, so a legacy leg fails with NETSDK1005
 #                           before the no-op shell can take effect. It is covered
 #                           by the fuzz-public-drop job instead.
+#   Native flow backends  - require verified x64 native assets and run in the
+#   and bindings            required native-data-channels reusable workflow.
+#                           The HTTP3 test host also uses TUnit rather than VSTest.
 $MainlineExclusions = @(
     'Opc.Ua.Aot.Tests.csproj',
     'Opc.Ua.Stress.Tests.csproj',
     'Opc.Ua.Subscriptions.Durable.Tests.csproj',
-    'Opc.Ua.OneFuzz.Validator.Tests.csproj')
+    'Opc.Ua.OneFuzz.Validator.Tests.csproj',
+    'Opc.Ua.Native.QuicGo.Tests.csproj',
+    'Opc.Ua.Native.Http3.Tests.csproj',
+    'Opc.Ua.Bindings.Quic.Tests.csproj',
+    'Opc.Ua.Bindings.WebTransport.Tests.csproj',
+    'Opc.Ua.DataChannel.ClientServer.Tests.csproj',
+    'Opc.Ua.DataChannel.Samples.Tests.csproj')
 
 $DurableProject = 'Opc.Ua.Subscriptions.Durable.Tests.csproj'
 

.github/scripts/get-test-verdict.ps1

@@ -11,13 +11,12 @@
     TRX parsing it consumes, in their own file lets both be tested without
     building or running anything.
 
-    The emitted TRX decides the verdict, not the 'dotnet test' exit code. A
-    non-zero exit is tolerated when - and only when - the results record at least
-    one *passing* test, no failure of any kind, and no test fixture whose setup or
-    teardown failed, which means the host died during process exit after the last
-    test and every teardown had already run. A host that dies mid-run leaves a
-    non-zero failed/aborted/passedButRunAborted counter and is rejected, and a
-    suite whose tests were all skipped is rejected as well.
+    The emitted TRX is the primary verdict. By default, the existing at-exit
+    tolerance accepts a non-zero exit only with passing results, no failure
+    counters, and no failed fixture setup or teardown. Counters alone cannot
+    distinguish every mid-run crash: VSTest can omit aborted counters after a
+    host dies. RequireCleanExit disables that tolerance for native qualification.
+    A suite whose tests were all skipped is always rejected.
 #>
 
 <#
@@ -48,6 +47,11 @@
  .PARAMETER ExitCode
     Exit code of the 'dotnet test' process.
 
+ .PARAMETER RequireCleanExit
+    Reject any non-zero host exit, even when the partial TRX contains only
+    passing counters. Native qualification uses this stricter policy without
+    changing the default tolerance for existing mainline test jobs.
+
  .PARAMETER TimedOut
     Whether the executor killed the process at its per-project ceiling.
 
@@ -70,7 +74,8 @@ function Get-TestRunVerdict
         [Parameter(Mandatory = $true)] [int] $ExitCode,
         [Parameter(Mandatory = $true)] [bool] $TimedOut,
         [Parameter(Mandatory = $false)] [int] $TimeoutMinutes = 0,
-        [Parameter(Mandatory = $false)] [string[]] $FixtureFailures = @()
+        [Parameter(Mandatory = $false)] [string[]] $FixtureFailures = @(),
+        [Parameter(Mandatory = $false)] [switch] $RequireCleanExit
     )
 
     # A timeout is never benign: the executor killed a process that was still
@@ -141,6 +146,13 @@ function Get-TestRunVerdict
     }
 
     if ($ExitCode -ne 0) {
+        if ($RequireCleanExit) {
+            return [pscustomobject]@{
+                Passed    = $false
+                Tolerated = $false
+                Reason    = "A clean host exit is required, but the test host exited with code $ExitCode."
+            }
+        }
         return [pscustomobject]@{
             Passed    = $true
             Tolerated = $true

.github/scripts/prepare-native-http3.ps1

@@ -0,0 +1,120 @@
+# Copyright (c) OPC Foundation. Licensed under the MIT License.
+<#
+.SYNOPSIS
+    Resolves and verifies the public Rust toolchain used by the native HTTP3 build.
+.DESCRIPTION
+    An existing isolated toolchain can be supplied without downloading anything.
+    Otherwise rustup installs the exact public release into build-private homes.
+    Executed compiler and runtime files are checked against the native package's
+    accepted public-input manifest. No default or system toolchain is changed.
+#>
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)][string] $ToolRoot,
+    [string] $ExistingToolchainRoot = ''
+)
+
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version Latest
+if (-not $IsWindows) {
+    throw 'This prepares Windows tools. Linux uses the separately pinned public Rust container.'
+}
+$repository = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\..'))
+$pins = Get-Content -LiteralPath (
+    Join-Path $repository 'src\Opc.Ua.Native.Http3\build\public-inputs.json') -Raw | ConvertFrom-Json
+$ToolRoot = [IO.Path]::GetFullPath($ToolRoot)
+
+if (-not [string]::IsNullOrWhiteSpace($ExistingToolchainRoot)) {
+    $toolchain = (Resolve-Path -LiteralPath $ExistingToolchainRoot).Path
+}
+else {
+    $rustup = (Get-Command rustup -CommandType Application -ErrorAction Stop).Source
+    New-Item -ItemType Directory -Path $ToolRoot -Force | Out-Null
+    $manifest = Join-Path $ToolRoot 'public-release-manifest.toml'
+    Invoke-WebRequest -Uri $pins.release_manifest_url -OutFile $manifest -TimeoutSec 120
+    if ((Get-FileHash -LiteralPath $manifest -Algorithm SHA256).Hash -ne $pins.release_manifest_sha256) {
+        throw 'The public Rust release manifest does not match the accepted hash.'
+    }
+
+    $environment = @{
+        RUSTUP_HOME = Join-Path $ToolRoot 'rustup'
+        CARGO_HOME = Join-Path $ToolRoot 'cargo'
+        RUSTUP_DIST_SERVER = 'https://static.rust-lang.org'
+        RUSTUP_UPDATE_ROOT = 'https://static.rust-lang.org/rustup'
+        RUSTUP_TOOLCHAIN = ''
+    }
+    $previous = @{}
+    foreach ($entry in $environment.GetEnumerator()) {
+        $previous[$entry.Key] = [Environment]::GetEnvironmentVariable($entry.Key, 'Process')
+        [Environment]::SetEnvironmentVariable($entry.Key, $entry.Value, 'Process')
+    }
+    try {
+        $selected = "$($pins.rust_version)-$($pins.windows.target)"
+        & $rustup toolchain install $selected --no-self-update --profile minimal `
+            --component rustfmt --component clippy --component rust-src | Out-Host
+        if ($LASTEXITCODE -ne 0) {
+            throw 'Could not install the exact public Rust release into the private build home.'
+        }
+        $toolchain = & $rustup run $selected rustc --print sysroot
+        if ($LASTEXITCODE -ne 0 -or [string]::IsNullOrWhiteSpace($toolchain)) {
+            throw 'The explicitly selected Rust toolchain did not report its root.'
+        }
+        $toolchain = [IO.Path]::GetFullPath($toolchain.Trim())
+    }
+    finally {
+        foreach ($entry in $previous.GetEnumerator()) {
+            [Environment]::SetEnvironmentVariable($entry.Key, $entry.Value, 'Process')
+        }
+    }
+}
+
+foreach ($file in $pins.windows.files) {
+    $path = Join-Path $toolchain $file.path
+    if (-not (Test-Path -LiteralPath $path -PathType Leaf)) {
+        throw "The selected public Rust toolchain is missing '$($file.path)'."
+    }
+    if ((Get-FileHash -LiteralPath $path -Algorithm SHA256).Hash -ne $file.sha256) {
+        throw "The selected public Rust toolchain differs at '$($file.path)'."
+    }
+}
+
+$vswhere = Join-Path ${env:ProgramFiles(x86)} 'Microsoft Visual Studio\Installer\vswhere.exe'
+if (-not (Test-Path -LiteralPath $vswhere -PathType Leaf)) {
+    throw 'Visual Studio discovery is unavailable; the pinned MSVC/SDK prerequisites must be installed.'
+}
+$installations = @(& $vswhere -all -products '*' -property installationPath)
+if ($LASTEXITCODE -ne 0) {
+    throw 'Visual Studio discovery failed.'
+}
+$visualStudio = $installations | Where-Object {
+    Test-Path -LiteralPath (Join-Path $_ "VC\Tools\MSVC\$($pins.windows.msvc_directory)") -PathType Container
+} | Select-Object -First 1
+if ([string]::IsNullOrWhiteSpace($visualStudio)) {
+    throw "The accepted MSVC $($pins.windows.msvc_directory) toolset is not installed."
+}
+$windowsSdk = Join-Path ${env:ProgramFiles(x86)} 'Windows Kits\10'
+$msvc = Join-Path $visualStudio "VC\Tools\MSVC\$($pins.windows.msvc_directory)"
+$nativeInputMismatches = [Collections.Generic.List[string]]::new()
+foreach ($file in $pins.windows.native_files) {
+    $base = switch ($file.base) {
+        'msvc' { $msvc }
+        'sdk' { $windowsSdk }
+        default { throw "Unknown native-tool input base '$($file.base)'." }
+    }
+    $path = Join-Path $base $file.path
+    $actualHash = (Get-FileHash -LiteralPath $path -Algorithm SHA256).Hash
+    if ($actualHash -ne $file.sha256) {
+        $nativeInputMismatches.Add(
+            "'$($file.path)' expected '$($file.sha256)', found '$actualHash'.")
+    }
+}
+if ($nativeInputMismatches.Count -gt 0) {
+    throw "The accepted MSVC/SDK inputs differ: $($nativeInputMismatches -join ' ')"
+}
+
+[pscustomobject]@{
+    ToolchainRoot = $toolchain
+    VisualStudioRoot = $visualStudio
+    WindowsSdkRoot = $windowsSdk
+    RustVersion = $pins.rust_version
+}

.github/scripts/prepare-native-quic.ps1

@@ -0,0 +1,141 @@
+# Copyright (c) OPC Foundation. Licensed under the MIT License.
+<#
+.SYNOPSIS
+    Prepares the pinned, private-to-this-build Windows tools and QUIC source.
+.DESCRIPTION
+    Reuses verified tools when present. New archives are checked before extraction,
+    and a mismatched existing installation is refused rather than overwritten.
+    The source copy stays outside GOMODCACHE so Go can apply the reviewed overlay.
+    No system installation or PATH configuration is changed.
+#>
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)][string] $ToolRoot,
+    [Parameter(Mandatory)][string] $CacheRoot,
+    [Parameter(Mandatory)][string] $QuicSourceRoot,
+    [Parameter(Mandatory)][string] $VerificationRoot
+)
+
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version Latest
+if (-not $IsWindows) {
+    throw 'The accepted cross-compilation toolchain runs on Windows and produces both x64 RIDs.'
+}
+
+$repository = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\..'))
+$project = Join-Path $repository 'src\Opc.Ua.Native.QuicGo'
+$pins = Get-Content -LiteralPath (Join-Path $project 'build\native-pins.json') -Raw | ConvertFrom-Json
+$ToolRoot = [IO.Path]::GetFullPath($ToolRoot)
+$CacheRoot = [IO.Path]::GetFullPath($CacheRoot)
+$QuicSourceRoot = [IO.Path]::GetFullPath($QuicSourceRoot)
+$VerificationRoot = [IO.Path]::GetFullPath($VerificationRoot)
+
+function Assert-FileHash([string] $Path, [string] $Expected)
+{
+    if (-not (Test-Path -LiteralPath $Path -PathType Leaf)) {
+        throw "Required pinned file is missing: $Path"
+    }
+    $actual = (Get-FileHash -LiteralPath $Path -Algorithm SHA256).Hash
+    if (-not [string]::Equals($actual, $Expected, [StringComparison]::OrdinalIgnoreCase)) {
+        throw "Pinned SHA256 mismatch for '$Path'; existing files were not overwritten."
+    }
+}
+
+function Install-PinnedTool(
+    [string] $Name,
+    [string] $ArchiveDirectory,
+    [string] $Executable,
+    [psobject] $Pin)
+{
+    $destination = Join-Path $ToolRoot $Name
+    $executablePath = Join-Path $destination $Executable
+    if (Test-Path -LiteralPath $destination) {
+        Assert-FileHash $executablePath $Pin.executable_sha256
+        return $executablePath
+    }
+
+    $archives = Join-Path $ToolRoot 'archives'
+    New-Item -ItemType Directory -Path $archives -Force | Out-Null
+    $archive = Join-Path $archives ([IO.Path]::GetFileName(([Uri] $Pin.archive_url).AbsolutePath))
+    if (-not (Test-Path -LiteralPath $archive)) {
+        $partial = "$archive.$([Guid]::NewGuid().ToString('N')).partial"
+        try {
+            Invoke-WebRequest -Uri $Pin.archive_url -OutFile $partial -TimeoutSec 180
+            Assert-FileHash $partial $Pin.archive_sha256
+            Move-Item -LiteralPath $partial -Destination $archive
+        }
+        finally {
+            if (Test-Path -LiteralPath $partial -PathType Leaf) {
+                Remove-Item -LiteralPath $partial -Force
+            }
+        }
+    }
+    Assert-FileHash $archive $Pin.archive_sha256
+
+    $stage = Join-Path $ToolRoot ".$Name-stage-$([Guid]::NewGuid().ToString('N'))"
+    New-Item -ItemType Directory -Path $stage | Out-Null
+    Expand-Archive -LiteralPath $archive -DestinationPath $stage
+    $extracted = Join-Path $stage $ArchiveDirectory
+    Assert-FileHash (Join-Path $extracted $Executable) $Pin.executable_sha256
+    Move-Item -LiteralPath $extracted -Destination $destination
+    # A successful extraction moves its only top-level directory. Never recursively
+    # delete a caller's tool root, including when extraction or validation fails.
+    Remove-Item -LiteralPath $stage
+    return $executablePath
+}
+
+New-Item -ItemType Directory -Path $ToolRoot,$CacheRoot,$VerificationRoot -Force | Out-Null
+$go = Install-PinnedTool 'go' 'go' 'bin\go.exe' $pins.go
+$zig = Install-PinnedTool 'zig' "zig-x86_64-windows-$($pins.zig.version)" 'zig.exe' $pins.zig
+
+$savedEnvironment = @{}
+$buildEnvironment = @{
+    GOROOT = Join-Path $ToolRoot 'go'
+    GOPATH = Join-Path $CacheRoot 'gopath'
+    GOMODCACHE = Join-Path $CacheRoot 'modules'
+    GOCACHE = Join-Path $CacheRoot 'compiled'
+    GOENV = 'off'
+    GOTOOLCHAIN = 'local'
+    GOTELEMETRY = 'off'
+    GOFLAGS = ''
+}
+foreach ($entry in $buildEnvironment.GetEnumerator()) {
+    $savedEnvironment[$entry.Key] = [Environment]::GetEnvironmentVariable($entry.Key, 'Process')
+    [Environment]::SetEnvironmentVariable($entry.Key, $entry.Value, 'Process')
+}
+Push-Location (Join-Path $project 'native')
+try {
+    $moduleJson = & $go mod download -json "$($pins.module)@$($pins.version)"
+    if ($LASTEXITCODE -ne 0) {
+        throw 'Could not acquire the checksum-pinned QUIC module.'
+    }
+    $module = $moduleJson | ConvertFrom-Json
+    if ($module.Sum -ne $pins.module_sum -or $module.GoModSum -ne $pins.module_mod_sum) {
+        throw 'The acquired QUIC module does not match the accepted module checksums.'
+    }
+    if (-not (Test-Path -LiteralPath $QuicSourceRoot)) {
+        $parent = Split-Path -Parent $QuicSourceRoot
+        New-Item -ItemType Directory -Path $parent -Force | Out-Null
+        Copy-Item -LiteralPath $module.Dir -Destination $QuicSourceRoot -Recurse
+    }
+    & python (Join-Path $project 'build\prepare_overlay.py') `
+        --source $QuicSourceRoot --verified-module $module.Dir --output $VerificationRoot
+    if ($LASTEXITCODE -ne 0) {
+        throw 'The source inventory or accepted QUIC overlays do not match.'
+    }
+}
+finally {
+    Pop-Location
+    foreach ($entry in $savedEnvironment.GetEnumerator()) {
+        [Environment]::SetEnvironmentVariable($entry.Key, $entry.Value, 'Process')
+    }
+}
+
+[pscustomobject]@{
+    ToolRoot = $ToolRoot
+    CacheRoot = $CacheRoot
+    QuicSourceRoot = $QuicSourceRoot
+    VerificationRoot = $VerificationRoot
+    Go = $go
+    Zig = $zig
+}