Add support for various transports, and mechanism to collect connectivity report

.github/workflows/test.yml

@@ -18,12 +18,14 @@ jobs:
         os: [ubuntu-latest, macos-latest, windows-2019]
 
     runs-on: ${{ matrix.os }}
+    env:
+      OUTPUT_DIR: ${{ github.workspace }}/out
 
     steps:
       - name: Check out code into the Go module directory
         uses: actions/checkout@v3
 
-      - name: Set up Go 1.20
+      - name: Set up Go
         uses: actions/setup-go@v4
         with:
           go-version-file: '${{ github.workspace }}/go.mod'
@@ -32,10 +34,26 @@ jobs:
         run: go build -v ./...
 
       - name: Build X
-        run: go build -C x -o bin/ -v ./...
+        run: go build -C x -o "${{ env.OUTPUT_DIR }}/" -v ./...
+
+      - name: Build Go Mobile
+        if: matrix.os == 'macos-latest' || matrix.os == 'ubuntu-latest'
+        run: go build -C x -o "${{ env.OUTPUT_DIR }}/" golang.org/x/mobile/cmd/gomobile golang.org/x/mobile/cmd/gobind
+
+      - name: Build Mobileproxy (Android)
+        if: matrix.os == 'ubuntu-latest'
+        run: PATH="${{ env.OUTPUT_DIR }}:$PATH" gomobile bind -ldflags='-s -w' -v -target=android -androidapi=21 -o "${{ env.OUTPUT_DIR }}/mobileproxy.aar" github.com/Jigsaw-Code/outline-sdk/x/mobileproxy
+        working-directory: ${{ github.workspace }}/x
+
+      - name: Build Mobileproxy (iOS)
+        if: matrix.os == 'macos-latest'
+        run: PATH="${{ env.OUTPUT_DIR }}:$PATH" gomobile bind -ldflags='-s -w' -v -target=ios -iosversion=11.0 -o "${{ env.OUTPUT_DIR }}/mobileproxy.xcframework" github.com/Jigsaw-Code/outline-sdk/x/mobileproxy
+        working-directory: ${{ github.workspace }}/x
 
       - name: Test SDK
-        run: go test -v -race -bench '.' ./... -benchtime=100ms
+        # Enable nettests, which executes external network requests.
+        run: go test -v -race -bench '.' ./... -benchtime=100ms -tags nettest
 
       - name: Test X
-        run: go test -C x -v -race -bench '.' ./... -benchtime=100ms
+        # Enable nettests, which executes external network requests.
+        run: go test -C x -v -race -bench '.' ./... -benchtime=100ms -tags nettest

CONTRIBUTING.md

@@ -42,25 +42,29 @@ In Go you can compile for other target operating system and architecture by spec
   <summary>Examples</summary>
 
 MacOS example:
-```
-% GOOS=darwin go build -C x -o ./bin/ ./outline-connectivity 
-% file ./x/bin/outline-connectivity 
-./x/bin/outline-connectivity: Mach-O 64-bit executable x86_64
+
+```console
+% GOOS=darwin go build -C x -o ./bin/ ./examples/test-connectivity 
+% file ./x/bin/test-connectivity 
+./x/bin/test-connectivity: Mach-O 64-bit executable x86_64
 ```
 
 Linux example:
-```
-% GOOS=linux go build -C x -o ./bin/ ./outline-connectivity 
-% file ./x/bin/outline-connectivity                      
-./x/bin/outline-connectivity: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, Go BuildID=n0WfUGLum4Y6OpYxZYuz/lbtEdv_kvyUCd3V_qOqb/CC_6GAQqdy_ebeYTdn99/Tk_G3WpBWi8vxqmIlIuU, with debug_info, not stripped
+
+```console
+% GOOS=linux go build -C x -o ./bin/ ./examples/test-connectivity 
+% file ./x/bin/test-connectivity                      
+./x/bin/test-connectivity: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, Go BuildID=n0WfUGLum4Y6OpYxZYuz/lbtEdv_kvyUCd3V_qOqb/CC_6GAQqdy_ebeYTdn99/Tk_G3WpBWi8vxqmIlIuU, with debug_info, not stripped
 ```
 
 Windows example:
+
+```console
+% GOOS=windows go build -C x -o ./bin/ ./examples/test-connectivity 
+% file ./x/bin/test-connectivity.exe 
+./x/bin/test-connectivity.exe: PE32+ executable (console) x86-64 (stripped to external PDB), for MS Windows
 ```
-% GOOS=windows go build -C x -o ./bin/ ./outline-connectivity 
-% file ./x/bin/outline-connectivity.exe 
-./x/bin/outline-connectivity.exe: PE32+ executable (console) x86-64 (stripped to external PDB), for MS Windows
-```
+
 </details>
 
 ## Running Linux binaries
@@ -72,41 +76,49 @@ To run Linux binaries you can use a Linux container via [Podman](https://podman.
   <summary>Instructions</summary>
 
 [Install Podman](https://podman.io/docs/installation) (once). On macOS:
+
 ```sh
 brew install podman
 ```
 
 Create the podman service VM (once) with the [`podman machine init` command](https://docs.podman.io/en/latest/markdown/podman-machine-init.1.html):
+
 ```sh
 podman machine init
 ```
 
 Start the VM with the [`podman machine start` command](https://docs.podman.io/en/latest/markdown/podman-machine-start.1.html), after every time it is stopped:
+
 ```sh
 podman machine start
-``` 
+```
 
 You can see the VM running with the [`podman machine list` command](https://docs.podman.io/en/latest/markdown/podman-machine-list.1.html):
-```
+
+```console
 % podman machine list
 NAME                     VM TYPE     CREATED        LAST UP            CPUS        MEMORY      DISK SIZE
 podman-machine-default*  qemu        3 minutes ago  Currently running  1           2.147GB     107.4GB
 ```
 
 When you are done with development, you can stop the machine with the [`podman machine stop` command](https://docs.podman.io/en/latest/markdown/podman-machine-stop.1.html):
+
 ```sh
 podman machine stop
 ```
+
 </details>
 
 ### Run
 
 The easiest way is to run a binary is to use the [`go run` command](https://pkg.go.dev/cmd/go#hdr-Compile_and_run_Go_program) directly with the `-exec` flag and our convenience tool `run_on_podman.sh`:
+
 ```sh
-GOOS=linux go run -C x -exec "$(pwd)/run_on_podman.sh" ./outline-connectivity
+GOOS=linux go run -C x -exec "$(pwd)/run_on_podman.sh" ./examples/test-connectivity
 ```
 
 It also works with the [`go test` command](https://pkg.go.dev/cmd/go#hdr-Test_packages):
+
 ```sh
 GOOS=linux go test -exec "$(pwd)/run_on_podman.sh"  ./...
 ```
@@ -115,14 +127,16 @@ GOOS=linux go test -exec "$(pwd)/run_on_podman.sh"  ./...
   <summary>Details and direct invocation</summary>
 
 The `run_on_podman.sh` script uses the [`podman run` command](https://docs.podman.io/en/latest/markdown/podman-run.1.html) and a minimal ["distroless" container image](https://github.com/GoogleContainerTools/distroless) to run the binary you want:
+
 ```sh
 podman run --arch $(uname -m) --rm -it -v "${bin}":/outline/bin gcr.io/distroless/static-debian11 /outline/bin "$@"
 ```
 
 You can also use `podman run` directly to run a pre-built binary:
-```
-% podman run --rm -it -v ./x/bin:/outline gcr.io/distroless/static-debian11 /outline/outline-connectivity
-Usage of /outline/outline-connectivity:
+
+```console
+% podman run --rm -it -v ./x/bin:/outline gcr.io/distroless/static-debian11 /outline/test-connectivity
+Usage of /outline/test-connectivity:
   -domain string
         Domain name to resolve in the test (default "example.com.")
   -key string
@@ -153,14 +167,16 @@ This is not the same as a real Windows environment, so make sure you test on act
 
 Follow the instructions at https://wiki.winehq.org/Download.
 
-On macOS: 
-```
+On macOS:
+
+```sh
 brew tap homebrew/cask-versions
 brew install --cask --no-quarantine wine-stable
 ```
 
 After installation, `wine64` should be on your `PATH`. Check with `wine64 --version`:
-```
+
+```sh
 wine64 --version
 ```
 
@@ -173,10 +189,21 @@ You can pass `wine64` as the `-exec` parameter in the `go` calls.
 To build:
 
 ```sh
-GOOS=windows go run -C x -exec "wine64" ./outline-connectivity
+GOOS=windows go run -C x -exec "wine64" ./examples/test-connectivity
 ```
 
 For tests:
+
 ```sh
 GOOS=windows go test -exec "wine64"  ./...
 ```
+
+# Tests with external network dependencies
+
+Some tests are implemented talking to external services. That's undesirable, but convenient.
+We started tagging them with the `nettest` tag, so they don't run by default. To run them, you need to specify `-tags nettest`, as done in our CI.
+For example:
+
+```sh
+go test -v -race -bench '.' ./... -benchtime=100ms -tags nettest
+```