init: separate from quic-go tree

.github/workflows/build-interop-docker.yml

@@ -0,0 +1,27 @@
+name: Build interop Docker image
+on: 
+  push:
+    branches: [ interop ]
+  
+jobs:
+  interop:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+        with:
+          platforms: linux/amd64,linux/arm64
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - uses: docker/build-push-action@v4
+        with:
+          context: "{{defaultContext}}:interop"
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: martenseemann/quic-go-interop:latest

.github/workflows/cross-compile.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+set -e
+
+dist="$1"
+goos=$(echo "$dist" | cut -d "/" -f1)
+goarch=$(echo "$dist" | cut -d "/" -f2)
+
+# cross-compiling for android is a pain...
+if [[ "$goos" == "android" ]]; then exit; fi
+# iOS builds require Cgo, see https://github.com/golang/go/issues/43343
+# Cgo would then need a C cross compilation setup. Not worth the hassle.
+if [[ "$goos" == "ios" ]]; then exit; fi
+
+# Write all log output to a temporary file instead of to stdout.
+# That allows running this script in parallel, while preserving the correct order of the output.
+log_file=$(mktemp)
+
+error_handler() {
+  cat "$log_file" >&2
+  rm "$log_file"
+  exit 1
+}
+
+trap 'error_handler' ERR
+
+echo "$dist" >> "$log_file"
+out="main-$goos-$goarch"
+GOOS=$goos GOARCH=$goarch go build -o $out example/main.go >> "$log_file" 2>&1
+rm $out
+
+cat "$log_file"
+rm "$log_file"

.github/workflows/cross-compile.yml

@@ -0,0 +1,23 @@
+on: [push, pull_request]
+jobs:
+  crosscompile:
+    strategy:
+      fail-fast: false
+      matrix:
+        go: [ "1.20.x", "1.21.0-rc.3" ]
+    runs-on: ${{ fromJSON(vars['CROSS_COMPILE_RUNNER_UBUNTU'] || '"ubuntu-latest"') }}
+    name: "Cross Compilation (Go ${{matrix.go}})"
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-go@v3
+        with:
+          go-version: ${{ matrix.go }}
+      - name: Install build utils
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-multilib
+      - name: Install dependencies
+        run: go build example/main.go
+      - name: Run cross compilation
+        # run in parallel on as many cores as are available on the machine
+        run: go tool dist list | xargs -I % -P "$(nproc)" .github/workflows/cross-compile.sh %

.github/workflows/go-generate.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+set -e
+
+DIR=$(pwd)
+TMP=$(mktemp -d)
+cd "$TMP"
+cp -r "$DIR" orig
+cp -r "$DIR" generated
+
+cd generated
+# delete all go-generated files generated (that adhere to the comment convention)
+grep --include \*.go -lrIZ "^// Code generated .* DO NOT EDIT\.$" . | xargs --null rm
+
+# First regenerate sys_conn_buffers_write.go.
+# If it doesn't exist, the following mockgen calls will fail.
+go generate -run "sys_conn_buffers_write.go"
+# now generate everything
+go generate ./...
+cd ..
+
+# don't compare fuzzing corpora
+diff --exclude=corpus --exclude=.git -ruN orig generated

.github/workflows/go-generate.yml

@@ -0,0 +1,13 @@
+on: [push, pull_request]
+jobs:
+  gogenerate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-go@v3
+        with:
+          go-version: "1.20.x"
+      - name: Install dependencies
+        run: go build
+      - name: Run code generators
+        run: .github/workflows/go-generate.sh

.github/workflows/integration.yml

@@ -0,0 +1,52 @@
+on: [push, pull_request]
+
+jobs:
+  integration:
+    strategy:
+      fail-fast: false
+      matrix:
+        go: [ "1.20.x", "1.21.0-rc.3" ]
+    runs-on: ${{ fromJSON(vars['INTEGRATION_RUNNER_UBUNTU'] || '"ubuntu-latest"') }}
+    env:
+      DEBUG: false # set this to true to export qlogs and save them as artifacts
+      TIMESCALE_FACTOR: 3
+    name: Integration Tests (Go ${{ matrix.go }})
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-go@v3
+        with:
+          stable: '!contains(${{ matrix.go }}, "beta") && !contains(${{ matrix.go }}, "rc")'
+          go-version: ${{ matrix.go }}
+      - run: go version
+      - name: set qlogger
+        if: env.DEBUG == 'true'
+        run: echo "QLOGFLAG= -qlog" >> $GITHUB_ENV
+      - name: Run other tests
+        run: |
+          go run github.com/onsi/ginkgo/v2/ginkgo -r -v -randomize-all -randomize-suites -trace -skip-package self,versionnegotiation integrationtests
+          go run github.com/onsi/ginkgo/v2/ginkgo -r -v -randomize-all -randomize-suites -trace integrationtests/versionnegotiation -- ${{ env.QLOGFLAG }}
+      - name: Run self tests, using QUIC v1
+        if: success() || failure() # run this step even if the previous one failed
+        run: go run github.com/onsi/ginkgo/v2/ginkgo -r -v -randomize-all -randomize-suites -trace integrationtests/self -- -version=1 ${{ env.QLOGFLAG }}
+      - name: Run self tests, using QUIC v2
+        if: success() || failure() # run this step even if the previous one failed
+        run: go run github.com/onsi/ginkgo/v2/ginkgo -r -v -randomize-all -randomize-suites -trace integrationtests/self -- -version=2 ${{ env.QLOGFLAG }}
+      - name: Run set tests, with GSO enabled
+        if: success() || failure() # run this step even if the previous one failed
+        env:
+          QUIC_GO_ENABLE_GSO: true
+        run: go run github.com/onsi/ginkgo/v2/ginkgo -r -v -randomize-all -randomize-suites -trace integrationtests/self -- -version=1 ${{ env.QLOGFLAG }}
+      - name: Run tests (32 bit)
+        if: success() || failure() # run this step even if the previous one failed
+        env:
+          GOARCH: 386
+        run: |
+          go run github.com/onsi/ginkgo/v2/ginkgo -r -v -randomize-all -randomize-suites -trace -skip-package self,versionnegotiation integrationtests
+          go run github.com/onsi/ginkgo/v2/ginkgo -r -v -randomize-all -randomize-suites -trace integrationtests/versionnegotiation -- ${{ env.QLOGFLAG }}
+          go run github.com/onsi/ginkgo/v2/ginkgo -r -v -randomize-all -randomize-suites -trace integrationtests/self -- ${{ env.QLOGFLAG }}
+      - name: save qlogs
+        if: ${{ always() && env.DEBUG == 'true' }}
+        uses: actions/upload-artifact@v2
+        with:
+          name: qlogs
+          path: integrationtests/self/*.qlog

.github/workflows/lint.yml

@@ -0,0 +1,73 @@
+on: [push, pull_request]
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-go@v3
+        with:
+          skip-pkg-cache: true
+          go-version: "1.20.x"
+      - name: Check that no non-test files import Ginkgo or Gomega
+        run: .github/workflows/no_ginkgo.sh
+      - name: Check that go.mod is tidied
+        run: |
+          cp go.mod go.mod.orig
+          cp go.sum go.sum.orig
+          go mod tidy
+          diff go.mod go.mod.orig
+          diff go.sum go.sum.orig
+      - name: Check that go mod vendor works
+        run: |
+          cd integrationtests/gomodvendor
+          go mod vendor
+  golangci-lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-go@v3
+        with:
+          go-version: "1.20.x"
+      - name: golangci-lint (Linux)
+        uses: golangci/golangci-lint-action@v3
+        with:
+          skip-pkg-cache: true
+          args: --timeout=3m
+          version: v1.52.2
+      - name: golangci-lint (Windows)
+        if: success() || failure() # run this step even if the previous one failed
+        uses: golangci/golangci-lint-action@v3
+        env:
+          GOOS: "windows"
+        with:
+          skip-pkg-cache: true
+          args: --timeout=3m
+          version: v1.52.2
+      - name: golangci-lint (OSX)
+        if: success() || failure() # run this step even if the previous one failed
+        uses: golangci/golangci-lint-action@v3
+        env:
+          GOOS: "darwin"
+        with:
+          skip-pkg-cache: true
+          args: --timeout=3m
+          version: v1.52.2
+      - name: golangci-lint (FreeBSD)
+        if: success() || failure() # run this step even if the previous one failed
+        uses: golangci/golangci-lint-action@v3
+        env:
+          GOOS: "freebsd"
+        with:
+          skip-pkg-cache: true
+          args: --timeout=3m
+          version: v1.52.2
+      - name: golangci-lint (others)
+        if: success() || failure() # run this step even if the previous one failed
+        uses: golangci/golangci-lint-action@v3
+        env:
+          GOOS: "solaris" # some OS that we don't have any build tags for
+        with:
+          skip-pkg-cache: true
+          args: --timeout=3m
+          version: v1.52.2

.github/workflows/no_ginkgo.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+
+# Verify that no non-test files import Ginkgo or Gomega.
+
+set -e
+
+HAS_TESTING=false
+
+cd ..
+for f in $(find . -name "*.go" ! -name "*_test.go" ! -name "tools.go"); do
+	if grep -q "github.com/onsi/ginkgo" $f; then
+    echo "$f imports github.com/onsi/ginkgo/v2"
+    HAS_TESTING=true
+	fi
+	if grep -q "github.com/onsi/gomega" $f; then
+    echo "$f imports github.com/onsi/gomega"
+    HAS_TESTING=true
+	fi
+done
+
+if "$HAS_TESTING"; then
+	exit 1
+fi
+exit 0

.github/workflows/unit.yml

@@ -0,0 +1,48 @@
+on: [push, pull_request]
+
+
+jobs:
+  unit:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ "ubuntu", "windows", "macos" ]
+        go: [ "1.20.x", "1.21.0-rc.3" ]
+    runs-on: ${{ fromJSON(vars[format('UNIT_RUNNER_{0}', matrix.os)] || format('"{0}-latest"', matrix.os)) }}
+    name: Unit tests (${{ matrix.os}}, Go ${{ matrix.go }})
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-go@v3
+        with:
+          go-version: ${{ matrix.go }}
+      - run: go version
+      - name: Run tests
+        env:
+          TIMESCALE_FACTOR: 10
+        run: go run github.com/onsi/ginkgo/v2/ginkgo -r -v -cover -randomize-all -randomize-suites -trace -skip-package integrationtests
+      - name: Run tests as root
+        if: ${{ matrix.os == 'ubuntu' }}
+        env:
+          TIMESCALE_FACTOR: 10
+          FILE: sys_conn_helper_linux_test.go
+        run: |
+          test -f $FILE # make sure the file actually exists
+          go run github.com/onsi/ginkgo/v2/ginkgo build -cover -tags root .
+          sudo ./quic-go.test -ginkgo.v -ginkgo.trace -ginkgo.randomize-all -ginkgo.focus-file=$FILE -test.coverprofile coverage-root.txt
+          rm quic-go.test
+      - name: Run tests (32 bit)
+        if: ${{ matrix.os != 'macos' }} # can't run 32 bit tests on OSX.
+        env:
+          TIMESCALE_FACTOR: 10
+          GOARCH: 386
+        run: go run github.com/onsi/ginkgo/v2/ginkgo -r -v -cover -coverprofile coverage.txt -output-dir . -randomize-all -randomize-suites -trace -skip-package integrationtests
+      - name: Run tests with race detector
+        if: ${{ matrix.os == 'ubuntu' }} # speed things up. Windows and OSX VMs are slow
+        env:
+          TIMESCALE_FACTOR: 20
+        run: go run github.com/onsi/ginkgo/v2/ginkgo -r -v -race -randomize-all -randomize-suites -trace -skip-package integrationtests
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v3
+        with:
+          files: coverage.txt,coverage-root.txt
+          env_vars: OS=${{ matrix.os }}, GO=${{ matrix.go }}