├── .codecov.yml ├── .github ├── FUNDING.yml ├── dependabot.yml └── workflows │ ├── ci.yml │ ├── coverage.yml │ ├── fuzz.yml │ ├── loc.yml │ └── net.yml ├── .gitignore ├── CHANGELOG.md ├── Cargo.toml ├── LICENSE ├── README.md ├── art ├── logo.png ├── logo.svg └── logo_72x72.png ├── ci ├── setup_subnet_macos.sh ├── setup_subnet_ubuntu.sh └── setup_subnet_windows.ps1 ├── examples └── toyconsul │ ├── Cargo.toml │ ├── README.md │ └── src │ └── main.rs ├── fuzz ├── .gitignore ├── Cargo.toml └── fuzz_targets │ └── messages.rs ├── rustfmt.toml ├── serf-core ├── Cargo.toml ├── README.md └── src │ ├── broadcast.rs │ ├── coalesce.rs │ ├── coalesce │ ├── member.rs │ └── user.rs │ ├── delegate.rs │ ├── delegate │ ├── composite.rs │ ├── merge.rs │ └── reconnect.rs │ ├── error.rs │ ├── event.rs │ ├── event │ └── crate_event.rs │ ├── key_manager.rs │ ├── lib.rs │ ├── options.rs │ ├── serf.rs │ ├── serf │ ├── api.rs │ ├── base.rs │ ├── base │ │ ├── tests.rs │ │ └── tests │ │ │ ├── serf.rs │ │ │ └── serf │ │ │ ├── delegate.rs │ │ │ ├── event.rs │ │ │ ├── join.rs │ │ │ ├── leave.rs │ │ │ ├── reap.rs │ │ │ ├── reconnect.rs │ │ │ ├── remove.rs │ │ │ └── snapshot.rs │ ├── delegate.rs │ ├── internal_query.rs │ └── query.rs │ ├── snapshot.rs │ ├── types.rs │ └── types │ ├── arbitrary_impl.rs │ ├── clock.rs │ ├── conflict.rs │ ├── coordinate.rs │ ├── filter.rs │ ├── filter │ └── tag_filter.rs │ ├── fuzzy.rs │ ├── join.rs │ ├── key.rs │ ├── leave.rs │ ├── member.rs │ ├── message.rs │ ├── push_pull.rs │ ├── query.rs │ ├── query │ └── response.rs │ ├── quickcheck_impl.rs │ ├── tags.rs │ ├── tests.rs │ ├── user_event.rs │ ├── user_event │ ├── message.rs │ └── user_events.rs │ └── version.rs └── serf ├── Cargo.toml ├── README.md ├── src ├── async_std.rs ├── lib.rs ├── smol.rs └── tokio.rs └── test ├── main.rs └── main ├── net.rs └── net ├── coordinates.rs ├── delegate.rs ├── delegate ├── local_state.rs ├── nodemeta.rs ├── ping_delegate.rs └── remote_state.rs ├── event.rs ├── event ├── default_query.rs ├── event_user.rs ├── event_user_size_limit.rs ├── events_failed.rs ├── events_join.rs ├── events_leave.rs ├── events_leave_avoid_infinite_rebroadcast.rs ├── query.rs ├── query_deduplicate.rs ├── query_filter.rs ├── query_old_message.rs ├── query_same_clock.rs ├── query_size_limit.rs ├── query_size_limit_increased.rs ├── remove_failed_events_leave.rs ├── should_process.rs ├── user_event_old_message.rs └── user_event_same_clock.rs ├── get_queue_max.rs ├── join.rs ├── join ├── intent_buffer_early.rs ├── intent_newer.rs ├── intent_old_message.rs ├── intent_reset_leaving.rs ├── join_cancel.rs ├── join_ignore_old.rs ├── join_leave.rs ├── join_leave_join.rs ├── leave_ltime.rs ├── pending_intent.rs └── pending_intents.rs ├── leave.rs ├── leave ├── force_leave_failed.rs ├── force_leave_leaving.rs ├── force_leave_left.rs ├── intent_buffer_early.rs ├── intent_newer.rs ├── intent_old_message.rs ├── rejoin_different_role.rs └── snapshot_recovery.rs ├── local_member.rs ├── name_resolution.rs ├── num_nodes.rs ├── reap.rs ├── reap ├── handler.rs ├── handler_shutdown.rs └── reap.rs ├── reconnect.rs ├── reconnect ├── reconnect.rs ├── same_ip.rs └── timeout.rs ├── remove.rs ├── remove ├── failed_node.rs ├── failed_node_ourself.rs └── failed_node_prune.rs ├── role.rs ├── set_tags.rs ├── snapshot.rs ├── snapshot ├── snapshoter.rs ├── snapshoter_force_compact.rs ├── snapshoter_leave.rs ├── snapshoter_leave_rejoin.rs └── snapshoter_recovery.rs ├── state.rs ├── stats.rs ├── update.rs └── write_keyring_file.rs /.codecov.yml: -------------------------------------------------------------------------------- 1 | codecov: 2 | require_ci_to_pass: false 3 | 4 | ignore: 5 | - serf-core/src/serf/base/tests 6 | - serf-core/src/serf/base/tests.rs 7 | - serf/test 8 | - fuzz/ 9 | - examples/ 10 | 11 | coverage: 12 | status: 13 | project: # Overall project status 14 | default: 15 | target: auto 16 | if_not_found: success 17 | only_pulls: false 18 | patch: # Status for the patch in pull requests 19 | default: 20 | target: auto 21 | if_not_found: success 22 | only_pulls: true 23 | changes: false # Whether to comment on the coverage changes in pull requests 24 | 25 | comment: 26 | layout: "header, diff, files, footer" 27 | behavior: default 28 | require_changes: false 29 | -------------------------------------------------------------------------------- /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | github: al8n 2 | patreon: al8n -------------------------------------------------------------------------------- /.github/dependabot.yml: -------------------------------------------------------------------------------- 1 | version: 2 2 | updates: 3 | - package-ecosystem: "cargo" 4 | directory: "/" 5 | schedule: 6 | interval: "weekly" 7 | open-pull-requests-limit: 50 8 | 9 | - package-ecosystem: "github-actions" 10 | directory: "/" 11 | schedule: 12 | # Check for updates to GitHub Actions every weekday 13 | interval: "daily" -------------------------------------------------------------------------------- /.github/workflows/ci.yml: -------------------------------------------------------------------------------- 1 | name: ci 2 | 3 | on: 4 | push: 5 | branches: 6 | - main 7 | paths-ignore: 8 | - 'README.md' 9 | - 'COPYRIGHT' 10 | - 'LICENSE*' 11 | - '**.md' 12 | - '**.txt' 13 | - 'art' 14 | pull_request: 15 | paths-ignore: 16 | - 'README.md' 17 | - 'COPYRIGHT' 18 | - 'LICENSE*' 19 | - '**.md' 20 | - '**.txt' 21 | - 'art' 22 | workflow_dispatch: 23 | schedule: [cron: "0 1 */7 * *"] 24 | 25 | jobs: 26 | test: 27 | name: ${{ matrix.os }} - ${{ matrix.runtime }} - ${{ matrix.stream_layer }} 28 | runs-on: ${{ matrix.os }} 29 | strategy: 30 | fail-fast: false 31 | matrix: 32 | os: 33 | - ubuntu-latest 34 | # - macos-latest, 35 | # - windows-latest 36 | runtime: [tokio, async-std, smol] 37 | stream_layer: 38 | # - tls 39 | # - native-tls 40 | - tcp 41 | steps: 42 | - uses: actions/checkout@v4 43 | 44 | - name: Install Rust 45 | run: | 46 | rustup update stable && rustup default stable 47 | rustup component add clippy 48 | rustup component add rustfmt 49 | 50 | - name: Install OpenSSL (Windows) 51 | if: matrix.os == 'windows-latest' 52 | shell: powershell 53 | run: | 54 | echo "VCPKG_ROOT=$env:VCPKG_INSTALLATION_ROOT" | Out-File -FilePath $env:GITHUB_ENV -Append 55 | vcpkg install openssl:x64-windows-static-md 56 | 57 | - name: Setup loopback interface (Windows) 58 | if: matrix.os == 'windows-latest' 59 | shell: powershell 60 | run: ci\setup_subnet_windows.ps1 61 | - name: Setup loopback interface (MacOS) 62 | if: matrix.os == 'macos-latest' 63 | run: ci/setup_subnet_macos.sh 64 | - name: Setup loopback interface (Ubuntu) 65 | if: matrix.os == 'ubuntu-latest' 66 | run: ci/setup_subnet_ubuntu.sh 67 | 68 | - name: Run Unit Tests for core 69 | run: | 70 | cargo test --no-default-features --features "test,encryption,serde,quickcheck" 71 | working-directory: serf-core 72 | 73 | - name: Cache Cargo registry 74 | uses: actions/cache@v4 75 | with: 76 | path: | 77 | ~/.cargo/registry 78 | ~/.cargo/git 79 | target 80 | key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}-${{ matrix.runtime }}-${{ matrix.stream_layer }} 81 | -------------------------------------------------------------------------------- /.github/workflows/coverage.yml: -------------------------------------------------------------------------------- 1 | name: coverage 2 | 3 | on: 4 | push: 5 | branches: 6 | - main 7 | paths-ignore: 8 | - 'README.md' 9 | - 'COPYRIGHT' 10 | - 'LICENSE*' 11 | - '**.md' 12 | - '**.txt' 13 | - 'art' 14 | pull_request: 15 | paths-ignore: 16 | - 'README.md' 17 | - 'COPYRIGHT' 18 | - 'LICENSE*' 19 | - '**.md' 20 | - '**.txt' 21 | - 'art' 22 | workflow_dispatch: 23 | 24 | env: 25 | CARGO_TERM_COLOR: always 26 | 27 | jobs: 28 | coverage-report: 29 | name: Generate Coverage for ${{ matrix.crate }}-${{ matrix.name }} 30 | runs-on: ubuntu-latest 31 | strategy: 32 | matrix: 33 | include: 34 | - crate: serf-core 35 | features: "test,metrics,quickcheck,encryption" 36 | name: "serf-core" 37 | - crate: serf 38 | features: "test,tokio,tcp,encryption,metrics" 39 | name: "serf-tcp-encryption" 40 | steps: 41 | - uses: actions/checkout@v4 42 | - name: Install latest nightly 43 | uses: actions-rs/toolchain@v1 44 | with: 45 | toolchain: nightly 46 | override: true 47 | - name: Setup loopback interface 48 | run: ci/setup_subnet_ubuntu.sh 49 | - name: Install cargo-tarpaulin 50 | run: cargo install cargo-tarpaulin 51 | - name: Run Coverage and Generate Report 52 | run: | 53 | cargo tarpaulin --out xml --no-default-features --features ${{ matrix.features }} --no-fail-fast --output-dir $PWD -j 1 54 | working-directory: ${{ matrix.crate }} 55 | continue-on-error: true 56 | - name: Upload Coverage Report as Artifact 57 | uses: actions/upload-artifact@v4 58 | with: 59 | name: ${{ matrix.name }} 60 | path: ${{ matrix.crate }}/cobertura.xml 61 | 62 | upload-codecov: 63 | needs: coverage-report 64 | runs-on: ubuntu-latest 65 | steps: 66 | - uses: actions/checkout@v4 67 | - name: Download all coverage reports 68 | uses: actions/download-artifact@v4 69 | with: 70 | path: reports/ 71 | - name: List contents of the reports directory 72 | run: ls -a reports 73 | - name: Upload to codecov.io 74 | uses: codecov/codecov-action@v5 75 | with: 76 | directory: reports 77 | fail_ci_if_error: false 78 | slug: ${{ github.repository }} 79 | env: 80 | CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} 81 | -------------------------------------------------------------------------------- /.github/workflows/fuzz.yml: -------------------------------------------------------------------------------- 1 | name: Fuzz Testing 2 | on: 3 | push: 4 | branches: 5 | - main 6 | paths-ignore: 7 | - 'README.md' 8 | - 'COPYRIGHT' 9 | - 'LICENSE*' 10 | - '**.md' 11 | - '**.txt' 12 | - 'art' 13 | pull_request: 14 | paths-ignore: 15 | - 'README.md' 16 | - 'COPYRIGHT' 17 | - 'LICENSE*' 18 | - '**.md' 19 | - '**.txt' 20 | - 'art' 21 | schedule: [cron: "0 1 */7 * *"] 22 | 23 | 24 | jobs: 25 | fuzz: 26 | runs-on: ubuntu-latest 27 | steps: 28 | - uses: actions/checkout@v4 29 | 30 | - name: Install Rust 31 | uses: dtolnay/rust-toolchain@master 32 | with: 33 | toolchain: nightly 34 | 35 | - name: Install cargo-fuzz 36 | run: cargo install cargo-fuzz 37 | 38 | - name: Run fuzzing 39 | run: | 40 | cargo fuzz build 41 | cargo fuzz run messages -- -max_len=4096 -max_total_time=300 42 | -------------------------------------------------------------------------------- /.github/workflows/loc.yml: -------------------------------------------------------------------------------- 1 | name: loc 2 | 3 | on: 4 | push: 5 | branches: 6 | - main 7 | paths-ignore: 8 | - 'README.md' 9 | - 'COPYRIGHT' 10 | - 'LICENSE*' 11 | - '**.md' 12 | - '**.txt' 13 | - 'art' 14 | pull_request: 15 | paths-ignore: 16 | - 'README.md' 17 | - 'COPYRIGHT' 18 | - 'LICENSE*' 19 | - '**.md' 20 | - '**.txt' 21 | - 'art' 22 | workflow_dispatch: 23 | 24 | jobs: 25 | loc: 26 | runs-on: ubuntu-latest 27 | steps: 28 | - uses: actions/checkout@v4 29 | 30 | - name: Install Rust 31 | run: | 32 | rustup update stable && rustup default stable 33 | rustup component add clippy 34 | rustup component add rustfmt 35 | 36 | - name: Install tokeit 37 | run: | 38 | cargo install tokeit --force 39 | 40 | - name: Count lines of code 41 | run: | 42 | tokeit 43 | 44 | - name: Upload loc to GitHub Gist 45 | uses: actions/github-script@v7 46 | with: 47 | github-token: ${{ secrets.GIST_PAT }} 48 | script: | 49 | const fs = require('fs'); 50 | const output = fs.readFileSync('tokeit.json', 'utf8'); 51 | const gistId = 'd29ceff54c025fe4e8b144a51efb9324'; 52 | await github.rest.gists.update({ 53 | gist_id: gistId, 54 | files: { 55 | "serf": { 56 | content: output 57 | } 58 | } 59 | }); 60 | console.log("Gist updated"); -------------------------------------------------------------------------------- /.github/workflows/net.yml: -------------------------------------------------------------------------------- 1 | name: net 2 | 3 | on: 4 | push: 5 | branches: 6 | - main 7 | paths-ignore: 8 | - 'README.md' 9 | - 'COPYRIGHT' 10 | - 'LICENSE*' 11 | - '**.md' 12 | - '**.txt' 13 | - 'art' 14 | pull_request: 15 | paths-ignore: 16 | - 'README.md' 17 | - 'COPYRIGHT' 18 | - 'LICENSE*' 19 | - '**.md' 20 | - '**.txt' 21 | - 'art' 22 | workflow_dispatch: 23 | schedule: [cron: "0 1 */7 * *"] 24 | 25 | jobs: 26 | test: 27 | name: ${{ matrix.os }} - ${{ matrix.runtime }} - ${{ matrix.stream_layer }} 28 | runs-on: ${{ matrix.os }} 29 | strategy: 30 | fail-fast: false 31 | matrix: 32 | os: 33 | - ubuntu-latest 34 | # - macos-latest, 35 | # - windows-latest 36 | runtime: [tokio, async-std, smol] 37 | stream_layer: 38 | - tls 39 | - tcp 40 | steps: 41 | - uses: actions/checkout@v4 42 | 43 | - name: Install Rust 44 | run: | 45 | rustup update stable && rustup default stable 46 | rustup component add clippy 47 | rustup component add rustfmt 48 | 49 | - name: Install OpenSSL (Windows) 50 | if: matrix.os == 'windows-latest' 51 | shell: powershell 52 | run: | 53 | echo "VCPKG_ROOT=$env:VCPKG_INSTALLATION_ROOT" | Out-File -FilePath $env:GITHUB_ENV -Append 54 | vcpkg install openssl:x64-windows-static-md 55 | 56 | - name: Setup loopback interface (Windows) 57 | if: matrix.os == 'windows-latest' 58 | shell: powershell 59 | run: ci\setup_subnet_windows.ps1 60 | - name: Setup loopback interface (MacOS) 61 | if: matrix.os == 'macos-latest' 62 | run: ci/setup_subnet_macos.sh 63 | - name: Setup loopback interface (Ubuntu) 64 | if: matrix.os == 'ubuntu-latest' 65 | run: ci/setup_subnet_ubuntu.sh 66 | 67 | - name: Run Unit Tests for serf based on net transport 68 | run: | 69 | cargo test --no-default-features --features "test,encryption,net,metrics,${{ matrix.runtime }},${{ matrix.stream_layer }}" -- --test-threads=1 70 | working-directory: serf 71 | 72 | - name: Cache Cargo registry 73 | uses: actions/cache@v4 74 | with: 75 | path: | 76 | ~/.cargo/registry 77 | ~/.cargo/git 78 | target 79 | key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}-${{ matrix.runtime }}-${{ matrix.stream_layer }} 80 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | /Cargo.lock 3 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Releases 2 | 3 | ## 0.3.0 4 | 5 | ### Features 6 | 7 | - Redesign `Delegate` trait, making it easier to implement for users. 8 | - Rewriting encoding/decoding to support forward and backward compitibility. 9 | - Support `zstd`, `brotli`, `lz4`, and `snappy` for compressing. 10 | - Support `crc32`, `xxhash64`, `xxhash32`, `xxhash3`, `murmur3` for checksuming. 11 | - Unify returned error, all exported APIs return `Error` on `Result::Err`. 12 | 13 | ### Example 14 | 15 | - Add [toyconsul](https://github.com/al8n/serf/tree/main/examples/toyconsul), a toy eventually consistent distributed registry. 16 | 17 | ### Breakage 18 | 19 | - Remove `native-tls` supports 20 | - Remove `s2n-quic` supports 21 | - Remove `TransformDelegate` trait to simplify `Delegate` trait 22 | - Remove `JoinError`, add an new `Error::Multiple` variant 23 | 24 | ### Testing 25 | 26 | - Add fuzzy testing for encoding/decoding 27 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [workspace] 2 | members = [ 3 | "serf", 4 | "serf-core", 5 | "examples/toyconsul", 6 | "fuzz", 7 | ] 8 | resolver = "3" 9 | 10 | [workspace.package] 11 | version = "0.3.1" 12 | edition = "2024" 13 | rust-version = "1.85.0" 14 | description = "A decentralized solution for service discovery and orchestration that is lightweight, highly available, and fault tolerant." 15 | repository = "https://github.com/al8n/serf" 16 | homepage = "https://github.com/al8n/serf" 17 | license = "MPL-2.0" 18 | keywords = ["swim", "gossip", "service-discovery", "serf", "memberlist"] 19 | categories = ["network-programming", "asynchronous"] 20 | readme = "README.md" 21 | 22 | [workspace.dependencies] 23 | byteorder = "1" 24 | derive_more = { version = "2", features = ["full"] } 25 | futures = { version = "0.3", default-features = false } 26 | serde = { version = "1", features = ["derive"] } 27 | humantime-serde = "1" 28 | indexmap = "2" 29 | thiserror = { version = "2", default-features = false } 30 | viewit = "0.1.5" 31 | regex = "1" 32 | smol_str = "0.3" 33 | smallvec = "1" 34 | rand = "0.9" 35 | 36 | arbitrary = { version = "1", default-features = false, features = ["derive"] } 37 | quickcheck = { version = "1", default-features = false } 38 | 39 | # memberlist-proto = { version = "0.1", path = "../memberlist/memberlist-proto", default-features = false } 40 | # memberlist-core = { version = "0.6", path = "../memberlist/memberlist-core", default-features = false } 41 | # memberlist = { version = "0.6", path = "../memberlist/memberlist", default-features = false } 42 | 43 | # memberlist-proto = { version = "0.1", default-features = false, git = "https://github.com/al8n/memberlist" } 44 | # memberlist-core = { version = "0.6", default-features = false, git = "https://github.com/al8n/memberlist" } 45 | # memberlist = { version = "0.6", default-features = false, git = "https://github.com/al8n/memberlist" } 46 | 47 | memberlist-proto = { version = "0.1", default-features = false } 48 | memberlist-core = { version = "0.6", default-features = false } 49 | memberlist = { version = "0.6", default-features = false } 50 | 51 | serf-core = { path = "serf-core", version = "0.3.0", default-features = false } 52 | serf = { path = "serf", version = "0.3.0", default-features = false } 53 | -------------------------------------------------------------------------------- /art/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/al8n/serf/71864609646acfb7372c7a2a98dd16733b5bda7e/art/logo.png -------------------------------------------------------------------------------- /art/logo_72x72.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/al8n/serf/71864609646acfb7372c7a2a98dd16733b5bda7e/art/logo_72x72.png -------------------------------------------------------------------------------- /ci/setup_subnet_macos.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # This script configures additional IPv4 and IPv6 addresses on the loopback interface on macOS. 4 | # Usage: ./script.sh [up|down] 5 | 6 | action=${1:-up} 7 | 8 | configure_ipv4() { 9 | for j in {0..2}; do 10 | for i in {2..255}; do 11 | if [ "$action" = "up" ]; then 12 | sudo ifconfig lo0 alias 127.0.$j.$i up 13 | else 14 | sudo ifconfig lo0 -alias 127.0.$j.$i 15 | fi 16 | done 17 | done 18 | } 19 | 20 | configure_ipv6() { 21 | # Example uses ULA (Unique Local Addresses) fc00::/7 for IPv6 to avoid potential conflicts. 22 | # Adjust the IPv6 range as needed for your specific use case. 23 | for i in {2..255}; do 24 | if [ "$action" = "up" ]; then 25 | sudo ifconfig lo0 inet6 alias fc00::1:$i/128 26 | else 27 | sudo ifconfig lo0 inet6 -alias fc00::1:$i 28 | fi 29 | done 30 | } 31 | 32 | # Check if the first additional IPv4 loopback address is set up 33 | if ifconfig lo0 | grep -q "127.0.0.2"; then 34 | echo "IPv4 additional loopback address detected." 35 | else 36 | echo "Setting up IPv4 additional loopback addresses." 37 | configure_ipv4 38 | fi 39 | 40 | # Check if the first additional IPv6 loopback address is set up 41 | if ifconfig lo0 | grep -q "fc00::1:2"; then 42 | echo "IPv6 additional loopback address detected." 43 | else 44 | echo "Setting up IPv6 additional loopback addresses." 45 | configure_ipv6 46 | fi 47 | 48 | # Remove addresses if the action is 'down' 49 | if [ "$action" = "down" ]; then 50 | echo "Removing configured IPv4 and IPv6 loopback addresses." 51 | configure_ipv4 52 | configure_ipv6 53 | fi 54 | -------------------------------------------------------------------------------- /ci/setup_subnet_ubuntu.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # 4 | # This script makes sure that 127.0.0.x and ::1:x are routable. On some systems, 5 | # there might be a need to explicitly add these addresses to the loopback interface. 6 | # 7 | 8 | action=${1:-up} 9 | 10 | # IPv4 Setup or Removal 11 | if [ "$action" = "up" ]; then 12 | # Check if IPv4 loopback is setup 13 | ip addr show lo | grep -q "127.0.0.2" 14 | if [ $? -eq 0 ]; then 15 | echo "IPv4 loopback address already set up." 16 | else 17 | for j in 0 1 2; do 18 | for i in {2..255}; do 19 | sudo ip addr add 127.0.$j.$i/8 dev lo 20 | done 21 | done 22 | fi 23 | else 24 | for j in 0 1 2; do 25 | for i in {2..255}; do 26 | sudo ip addr del 127.0.$j.$i/8 dev lo 27 | done 28 | done 29 | fi 30 | 31 | # IPv6 Setup or Removal 32 | if [ "$action" = "up" ]; then 33 | # Check if IPv6 loopback is setup 34 | ip -6 addr show lo | grep -q "::1:2" 35 | if [ $? -eq 0 ]; then 36 | echo "IPv6 loopback address already set up." 37 | else 38 | for i in {2..255}; do 39 | sudo ip -6 addr add fc00::1:$i/128 dev lo 40 | done 41 | fi 42 | else 43 | for i in {2..255}; do 44 | sudo ip -6 addr del fc00::1:$i/128 dev lo 45 | done 46 | fi 47 | -------------------------------------------------------------------------------- /ci/setup_subnet_windows.ps1: -------------------------------------------------------------------------------- 1 | param ( 2 | [string]$action = "up" 3 | ) 4 | 5 | function Test-IPAddress { 6 | param ( 7 | [string]$IPAddress, 8 | [string]$AddressFamily 9 | ) 10 | $ipExists = Get-NetIPAddress -AddressFamily $AddressFamily -IPAddress $IPAddress -ErrorAction SilentlyContinue 11 | return $ipExists -ne $null 12 | } 13 | 14 | $loopbackInterfaceIPv4 = Get-NetIPInterface -AddressFamily IPv4 | Where-Object { $_.InterfaceDescription -like "*Loopback*" } 15 | $loopbackInterfaceIPv6 = Get-NetIPInterface -AddressFamily IPv6 | Where-Object { $_.InterfaceDescription -like "*Loopback*" } 16 | 17 | if ($action -eq "up") { 18 | 0..2 | ForEach-Object { 19 | $subnet = $_ 20 | 2..255 | ForEach-Object { 21 | $ipAddress = "127.0.$subnet.$_" 22 | if (-not (Test-IPAddress -IPAddress $ipAddress -AddressFamily IPv4)) { 23 | Write-Host "Adding IPv4 address $ipAddress" 24 | New-NetIPAddress -IPAddress $ipAddress -PrefixLength 8 -InterfaceIndex $loopbackInterfaceIPv4.InterfaceIndex -ErrorAction SilentlyContinue 25 | } 26 | } 27 | } 28 | 29 | # Adjusting the IPv6 address addition logic for clarity and correctness 30 | 2..255 | ForEach-Object { 31 | # Constructing a proper IPv6 address string 32 | $ipAddress = "fc00::1:$_" 33 | if (-not (Test-IPAddress -IPAddress $ipAddress -AddressFamily IPv6)) { 34 | Write-Host "Adding IPv6 address $ipAddress" 35 | # Note: Specifying the correct prefix length for IPv6 ULA addresses, which is commonly 64, but here it is kept as 128 for individual addresses 36 | New-NetIPAddress -IPAddress $ipAddress -PrefixLength 128 -InterfaceIndex $loopbackInterfaceIPv6.InterfaceIndex -ErrorAction SilentlyContinue 37 | } 38 | } 39 | } else { 40 | 0..2 | ForEach-Object { 41 | $subnet = $_ 42 | 2..255 | ForEach-Object { 43 | $ipAddress = "127.0.$subnet.$_" 44 | if (Test-IPAddress -IPAddress $ipAddress -AddressFamily IPv4) { 45 | Write-Host "Removing IPv4 address $ipAddress" 46 | Remove-NetIPAddress -IPAddress $ipAddress -Confirm:$false -ErrorAction SilentlyContinue 47 | } 48 | } 49 | } 50 | 51 | 2..255 | ForEach-Object { 52 | $ipAddress = "fc00::1:$_" 53 | if (Test-IPAddress -IPAddress $ipAddress -AddressFamily IPv6) { 54 | Write-Host "Removing IPv6 address $ipAddress" 55 | Remove-NetIPAddress -IPAddress $ipAddress -Confirm:$false -ErrorAction SilentlyContinue 56 | } 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /examples/toyconsul/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "toyconsul" 3 | rust-version = "1.85.0" 4 | edition = "2024" 5 | publish = false 6 | 7 | [dependencies] 8 | bincode = "1" 9 | clap = { version = "4", features = ["derive"] } 10 | crossbeam-skiplist = "0.1" 11 | serf = { workspace = true, features = ["default", "tokio", "tcp", "serde"] } 12 | serde = { version = "1", features = ["derive"] } 13 | tracing = "0.1" 14 | tracing-subscriber = { version = "0.3", features = ["env-filter"] } 15 | tokio = { version = "1", features = ["full"] } 16 | scopeguard = "1" 17 | -------------------------------------------------------------------------------- /examples/toyconsul/README.md: -------------------------------------------------------------------------------- 1 | # ToyConsul 2 | 3 | A toy eventually consistent distributed registry. 4 | 5 | ## Installation 6 | 7 | ```bash 8 | cargo install --path . 9 | ``` 10 | 11 | ## Run 12 | 13 | - In the first terminal 14 | 15 | ```bash 16 | toyconsul start --id instance1 --addr 127.0.0.1:7001 --rpc-addr toyconsul.instance1.sock 17 | ``` 18 | 19 | - In the second terminal 20 | 21 | - Start instance 2 22 | 23 | ```bash 24 | toyconsul start --id instance2 --addr 127.0.0.1:7002 --rpc-addr toyconsul.instance2.sock 25 | ``` 26 | 27 | - Send the join command to instance2 and let it join to instance1 28 | 29 | ```bash 30 | toyconsul join --id instance1 --addr 127.0.0.1:7001 --rpc-addr toyconsul.instance2.sock 31 | ``` 32 | 33 | - In the third terminal 34 | 35 | - Start instance 3 36 | 37 | ```bash 38 | toyconsul start --id instance3 --addr 127.0.0.1:7003 --rpc-addr toyconsul.instance3.sock 39 | ``` 40 | 41 | - Send the join command to instance3 and let it join to instance1 (can also join to instance 2) 42 | 43 | ```bash 44 | toyconsul join --id instance1 --addr 127.0.0.1:7001 --rpc-addr toyconsul.instance3.sock 45 | ``` 46 | 47 | - In the fourth terminal 48 | 49 | - Insert a key - value to the instance1 50 | 51 | ```bash 52 | toyconsul register --name web --addr 192.0.0.1:8080 --rpc-addr toyconsul.instance1.sock 53 | toyconsul register --name db --addr 192.0.0.1:8081 --rpc-addr toyconsul.instance2.sock 54 | ``` 55 | 56 | - After some seconds, you can get the value from any one of three instances 57 | 58 | ```bash 59 | toyconsul list --rpc-addr toyconsul.instance1.sock 60 | ``` 61 | 62 | ```bash 63 | toyconsul list --rpc-addr toyconsul.instance2.sock 64 | ``` 65 | 66 | ```bash 67 | toyconsul list --rpc-addr toyconsul.instance3.sock 68 | ``` 69 | -------------------------------------------------------------------------------- /fuzz/.gitignore: -------------------------------------------------------------------------------- 1 | target 2 | corpus 3 | artifacts 4 | coverage 5 | -------------------------------------------------------------------------------- /fuzz/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "serf-types-fuzz" 3 | version = "0.0.0" 4 | publish = false 5 | edition = "2024" 6 | 7 | [package.metadata] 8 | cargo-fuzz = true 9 | 10 | [dependencies] 11 | libfuzzer-sys = "0.4" 12 | 13 | serf-core = { workspace = true, features = ["arbitrary", "default", "encryption", "test"] } 14 | 15 | [[bin]] 16 | name = "messages" 17 | path = "fuzz_targets/messages.rs" 18 | test = false 19 | doc = false 20 | bench = false 21 | -------------------------------------------------------------------------------- /fuzz/fuzz_targets/messages.rs: -------------------------------------------------------------------------------- 1 | #![no_main] 2 | #![allow(clippy::type_complexity)] 3 | 4 | use libfuzzer_sys::fuzz_target; 5 | 6 | use serf_core::types::{ 7 | Node, 8 | fuzzy::{Message, encodable_round_trip}, 9 | }; 10 | 11 | fuzz_target!( 12 | |data: (Message>, Option>>)| { 13 | assert!(encodable_round_trip(data.0, data.1)); 14 | } 15 | ); 16 | -------------------------------------------------------------------------------- /rustfmt.toml: -------------------------------------------------------------------------------- 1 | max_width = 100 2 | hard_tabs = false 3 | tab_spaces = 2 4 | newline_style = "Auto" 5 | use_small_heuristics = "Default" 6 | reorder_imports = true 7 | reorder_modules = true 8 | remove_nested_parens = true 9 | merge_derives = true 10 | imports_granularity="Crate" 11 | use_try_shorthand = true 12 | use_field_init_shorthand = true 13 | force_explicit_abi = true 14 | 15 | -------------------------------------------------------------------------------- /serf-core/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "serf-core" 3 | version.workspace = true 4 | rust-version.workspace = true 5 | edition.workspace = true 6 | license.workspace = true 7 | description.workspace = true 8 | repository.workspace = true 9 | readme.workspace = true 10 | homepage.workspace = true 11 | keywords.workspace = true 12 | categories.workspace = true 13 | 14 | [features] 15 | default = ["metrics"] 16 | metrics = ["memberlist-core/metrics", "dep:metrics"] 17 | 18 | encryption = ["memberlist-core/encryption", "serde", "serde_json"] 19 | 20 | crc32 = ["memberlist-core/crc32"] 21 | murmur3 = ["memberlist-core/murmur3"] 22 | xxhash64 = ["memberlist-core/xxhash64"] 23 | xxhash32 = ["memberlist-core/xxhash32"] 24 | xxhash3 = ["memberlist-core/xxhash3"] 25 | 26 | snappy = ["memberlist-core/snappy"] 27 | zstd = ["memberlist-core/zstd"] 28 | lz4 = ["memberlist-core/lz4"] 29 | brotli = ["memberlist-core/brotli"] 30 | 31 | serde = [ 32 | "dep:serde", 33 | "dep:humantime-serde", 34 | "bitflags/serde", 35 | "memberlist-core/serde", 36 | "smol_str/serde", 37 | "smallvec/serde", 38 | "indexmap/serde", 39 | ] 40 | 41 | test = ["memberlist-core/test", "paste", "tracing-subscriber", "tempfile"] 42 | 43 | arbitrary = ["dep:arbitrary", "memberlist-core/arbitrary", "smol_str/arbitrary"] 44 | quickcheck = ["dep:quickcheck", "memberlist-core/quickcheck"] 45 | 46 | [dependencies] 47 | auto_impl = "1" 48 | atomic_refcell = "0.1" 49 | arc-swap = "1" 50 | async-lock = "3" 51 | async-channel = "2" 52 | bitflags = "2" 53 | byteorder.workspace = true 54 | crossbeam-queue = "0.3" 55 | derive_more.workspace = true 56 | futures = { workspace = true, features = ["default"] } 57 | either = "1" 58 | indexmap.workspace = true 59 | once_cell = "1" # remove this dependency when [feature(lazy_cell)] is stabilized 60 | parking_lot = { version = "0.12", features = ["send_guard"] } 61 | pin-project = "1" 62 | rand.workspace = true 63 | regex.workspace = true 64 | scopeguard = "1" 65 | smol_str.workspace = true 66 | smallvec.workspace = true 67 | thiserror.workspace = true 68 | viewit.workspace = true 69 | memberlist-core.workspace = true 70 | 71 | metrics = { version = "0.24", optional = true } 72 | 73 | serde = { workspace = true, optional = true } 74 | humantime-serde = { workspace = true, optional = true } 75 | serde_json = { version = "1", optional = true } 76 | 77 | arbitrary = { workspace = true, optional = true, default-features = false, features = ["derive"] } 78 | quickcheck = { workspace = true, optional = true, default-features = false } 79 | 80 | # test features 81 | paste = { version = "1", optional = true } 82 | tracing-subscriber = { version = "0.3", optional = true, features = [ 83 | "env-filter", 84 | "tracing-log", 85 | ] } 86 | tempfile = { version = "3", optional = true } 87 | 88 | [dev-dependencies] 89 | agnostic-lite = { version = "0.5", features = ["tokio"] } 90 | tokio = { version = "1", features = ["full"] } 91 | futures = { workspace = true, features = ["executor"] } 92 | tempfile = "3" 93 | memberlist-core = { workspace = true, features = ["quickcheck", "arbitrary", "test"] } 94 | quickcheck_macros = "1" 95 | quickcheck.workspace = true 96 | paste = "1" 97 | 98 | [package.metadata.docs.rs] 99 | all-features = true 100 | rustdoc-args = ["--cfg", "docsrs"] -------------------------------------------------------------------------------- /serf-core/README.md: -------------------------------------------------------------------------------- 1 | ../README.md -------------------------------------------------------------------------------- /serf-core/src/broadcast.rs: -------------------------------------------------------------------------------- 1 | use async_channel::Sender; 2 | use memberlist_core::{Broadcast, bytes::Bytes}; 3 | 4 | #[derive(Debug, PartialEq, Eq, Hash, Clone)] 5 | pub(crate) struct BroadcastId; 6 | 7 | impl core::fmt::Display for BroadcastId { 8 | fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 9 | Ok(()) 10 | } 11 | } 12 | 13 | #[viewit::viewit] 14 | #[derive(Debug)] 15 | pub(crate) struct SerfBroadcast { 16 | msg: Bytes, 17 | notify_tx: Option>, 18 | } 19 | 20 | impl Broadcast for SerfBroadcast { 21 | type Id = BroadcastId; 22 | type Message = Bytes; 23 | 24 | fn id(&self) -> Option<&Self::Id> { 25 | None 26 | } 27 | 28 | fn invalidates(&self, _other: &Self) -> bool { 29 | false 30 | } 31 | 32 | fn message(&self) -> &Self::Message { 33 | &self.msg 34 | } 35 | 36 | async fn finished(&self) { 37 | if let Some(ref tx) = self.notify_tx { 38 | let _ = tx.send(()).await; 39 | } 40 | } 41 | 42 | fn encoded_len(msg: &Self::Message) -> usize { 43 | msg.len() 44 | } 45 | } 46 | 47 | #[cfg(test)] 48 | #[tokio::test] 49 | async fn test_broadcast_finished() { 50 | use futures::{self, FutureExt}; 51 | use std::time::Duration; 52 | 53 | let (tx, rx) = async_channel::unbounded(); 54 | 55 | let b = SerfBroadcast { 56 | msg: Bytes::new(), 57 | notify_tx: Some(tx), 58 | }; 59 | 60 | b.finished().await; 61 | 62 | futures::select! { 63 | _ = rx.recv().fuse() => {} 64 | _ = tokio::time::sleep(Duration::from_millis(10)).fuse() => { 65 | panic!("expected broadcast to be finished") 66 | } 67 | } 68 | } 69 | 70 | #[cfg(test)] 71 | #[tokio::test] 72 | async fn test_broadcast_finished_no_sender() { 73 | let b = SerfBroadcast { 74 | msg: Bytes::new(), 75 | notify_tx: None, 76 | }; 77 | 78 | b.finished().await; 79 | } 80 | -------------------------------------------------------------------------------- /serf-core/src/delegate.rs: -------------------------------------------------------------------------------- 1 | use memberlist_core::{CheapClone, transport::Id}; 2 | 3 | mod merge; 4 | pub use merge::*; 5 | 6 | mod reconnect; 7 | pub use reconnect::*; 8 | 9 | mod composite; 10 | pub use composite::*; 11 | 12 | /// [`Delegate`] is the trait that clients must implement if they want to hook 13 | /// into the gossip layer of [`Serf`](crate::Serf). All the methods must be thread-safe, 14 | /// as they can and generally will be called concurrently. 15 | pub trait Delegate: 16 | MergeDelegate::Id, Address = ::Address> 17 | + ReconnectDelegate::Id, Address = ::Address> 18 | { 19 | /// The id type of the delegate 20 | type Id: Id; 21 | /// The address type of the delegate 22 | type Address: CheapClone + Send + Sync + 'static; 23 | } 24 | -------------------------------------------------------------------------------- /serf-core/src/delegate/composite.rs: -------------------------------------------------------------------------------- 1 | use memberlist_core::{CheapClone, transport::Id}; 2 | 3 | use crate::types::Member; 4 | 5 | use super::{ 6 | DefaultMergeDelegate, Delegate, MergeDelegate, NoopReconnectDelegate, ReconnectDelegate, 7 | }; 8 | 9 | use std::sync::Arc; 10 | 11 | /// `CompositeDelegate` is a helpful struct to split the [`Delegate`] into multiple small delegates, 12 | /// so that users do not need to implement full [`Delegate`] when they only want to custom some methods 13 | /// in the [`Delegate`]. 14 | pub struct CompositeDelegate, R = NoopReconnectDelegate> 15 | { 16 | merge: M, 17 | reconnect: R, 18 | _m: std::marker::PhantomData<(I, A)>, 19 | } 20 | 21 | impl Default for CompositeDelegate { 22 | fn default() -> Self { 23 | Self::new() 24 | } 25 | } 26 | 27 | impl CompositeDelegate { 28 | /// Returns a new `CompositeDelegate`. 29 | pub fn new() -> Self { 30 | Self { 31 | merge: Default::default(), 32 | reconnect: Default::default(), 33 | _m: std::marker::PhantomData, 34 | } 35 | } 36 | } 37 | 38 | impl CompositeDelegate 39 | where 40 | M: MergeDelegate, 41 | { 42 | /// Set the [`MergeDelegate`] for the `CompositeDelegate`. 43 | pub fn with_merge_delegate(self, merge: NM) -> CompositeDelegate { 44 | CompositeDelegate { 45 | merge, 46 | reconnect: self.reconnect, 47 | _m: std::marker::PhantomData, 48 | } 49 | } 50 | } 51 | 52 | impl CompositeDelegate { 53 | /// Set the [`ReconnectDelegate`] for the `CompositeDelegate`. 54 | pub fn with_reconnect_delegate(self, reconnect: NR) -> CompositeDelegate { 55 | CompositeDelegate { 56 | reconnect, 57 | merge: self.merge, 58 | _m: std::marker::PhantomData, 59 | } 60 | } 61 | } 62 | 63 | impl MergeDelegate for CompositeDelegate 64 | where 65 | I: Id + Send + Sync + 'static, 66 | A: CheapClone + Send + Sync + 'static, 67 | M: MergeDelegate, 68 | R: Send + Sync + 'static, 69 | { 70 | type Error = M::Error; 71 | 72 | type Id = M::Id; 73 | 74 | type Address = M::Address; 75 | 76 | async fn notify_merge( 77 | &self, 78 | members: Arc<[Member]>, 79 | ) -> Result<(), Self::Error> { 80 | self.merge.notify_merge(members).await 81 | } 82 | } 83 | 84 | impl ReconnectDelegate for CompositeDelegate 85 | where 86 | I: Id + Send + Sync + 'static, 87 | A: CheapClone + Send + Sync + 'static, 88 | M: Send + Sync + 'static, 89 | R: ReconnectDelegate, 90 | { 91 | type Id = R::Id; 92 | 93 | type Address = R::Address; 94 | 95 | fn reconnect_timeout( 96 | &self, 97 | member: &Member, 98 | timeout: std::time::Duration, 99 | ) -> std::time::Duration { 100 | self.reconnect.reconnect_timeout(member, timeout) 101 | } 102 | } 103 | 104 | impl Delegate for CompositeDelegate 105 | where 106 | I: Id + Send + Sync + 'static, 107 | A: CheapClone + Send + Sync + 'static, 108 | M: MergeDelegate, 109 | R: ReconnectDelegate, 110 | { 111 | type Id = I; 112 | 113 | type Address = A; 114 | } 115 | -------------------------------------------------------------------------------- /serf-core/src/delegate/merge.rs: -------------------------------------------------------------------------------- 1 | use memberlist_core::{CheapClone, transport::Id}; 2 | use std::{future::Future, sync::Arc}; 3 | 4 | use crate::types::Member; 5 | 6 | /// Used to involve a client in 7 | /// a potential cluster merge operation. Namely, when 8 | /// a node does a promised push/pull (as part of a join), 9 | /// the delegate is involved and allowed to cancel the join 10 | /// based on custom logic. The merge delegate is NOT invoked 11 | /// as part of the push-pull anti-entropy. 12 | #[auto_impl::auto_impl(Box, Arc)] 13 | pub trait MergeDelegate: Send + Sync + 'static { 14 | /// The error type of the delegate 15 | type Error: std::error::Error + Send + Sync + 'static; 16 | /// The id type of the delegate 17 | type Id: Id; 18 | /// The address type of the delegate 19 | type Address: CheapClone + Send + Sync + 'static; 20 | 21 | /// Invoked when a merge could take place. 22 | /// Provides a list of the nodes known by the peer. If 23 | /// the return value is `Err`, the merge is canceled. 24 | fn notify_merge( 25 | &self, 26 | members: Arc<[Member]>, 27 | ) -> impl Future> + Send; 28 | } 29 | 30 | /// A default implementation of the `MergeDelegate` trait. 31 | #[derive(Debug, Clone, Copy)] 32 | pub struct DefaultMergeDelegate(std::marker::PhantomData<(I, A)>); 33 | 34 | impl Default for DefaultMergeDelegate { 35 | fn default() -> Self { 36 | Self(Default::default()) 37 | } 38 | } 39 | 40 | impl MergeDelegate for DefaultMergeDelegate 41 | where 42 | I: Id + Send + Sync + 'static, 43 | A: CheapClone + Send + Sync + 'static, 44 | { 45 | type Error = std::convert::Infallible; 46 | type Id = I; 47 | type Address = A; 48 | 49 | async fn notify_merge( 50 | &self, 51 | _members: Arc<[Member]>, 52 | ) -> Result<(), Self::Error> { 53 | Ok(()) 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /serf-core/src/delegate/reconnect.rs: -------------------------------------------------------------------------------- 1 | use std::time::Duration; 2 | 3 | use memberlist_core::{CheapClone, transport::Id}; 4 | 5 | use crate::types::Member; 6 | 7 | /// Implemented to allow overriding the reconnect timeout for individual members. 8 | #[auto_impl::auto_impl(Box, Arc)] 9 | pub trait ReconnectDelegate: Send + Sync + 'static { 10 | /// The id type of the delegate 11 | type Id: Id; 12 | /// The address type of the delegate 13 | type Address: CheapClone + Send + Sync + 'static; 14 | 15 | /// Returns the reconnect timeout for the given member. 16 | fn reconnect_timeout( 17 | &self, 18 | member: &Member, 19 | timeout: Duration, 20 | ) -> Duration; 21 | } 22 | 23 | /// Noop implementation of `ReconnectDelegate`. 24 | #[derive(Debug)] 25 | pub struct NoopReconnectDelegate(std::marker::PhantomData<(I, A)>); 26 | 27 | impl Default for NoopReconnectDelegate { 28 | fn default() -> Self { 29 | Self(Default::default()) 30 | } 31 | } 32 | 33 | impl Clone for NoopReconnectDelegate { 34 | fn clone(&self) -> Self { 35 | *self 36 | } 37 | } 38 | 39 | impl Copy for NoopReconnectDelegate {} 40 | 41 | impl ReconnectDelegate for NoopReconnectDelegate 42 | where 43 | I: Id + Send + Sync + 'static, 44 | A: CheapClone + Send + Sync + 'static, 45 | { 46 | type Id = I; 47 | type Address = A; 48 | 49 | fn reconnect_timeout( 50 | &self, 51 | _member: &Member, 52 | timeout: Duration, 53 | ) -> Duration { 54 | timeout 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /serf-core/src/lib.rs: -------------------------------------------------------------------------------- 1 | #![doc = include_str!("../README.md")] 2 | #![doc(html_logo_url = "https://raw.githubusercontent.com/al8n/serf/main/art/logo_72x72.png")] 3 | #![forbid(unsafe_code)] 4 | // #![deny(warnings, missing_docs)] 5 | #![allow(clippy::type_complexity)] 6 | #![cfg_attr(docsrs, feature(doc_cfg))] 7 | #![cfg_attr(docsrs, allow(unused_attributes))] 8 | 9 | pub(crate) mod broadcast; 10 | 11 | mod coalesce; 12 | 13 | /// Events for [`Serf`] 14 | pub mod event; 15 | 16 | /// Errors for `serf`. 17 | pub mod error; 18 | 19 | /// Delegate traits and its implementations. 20 | pub mod delegate; 21 | 22 | mod options; 23 | pub use options::*; 24 | 25 | /// The types used in `serf`. 26 | pub mod types; 27 | pub use types::coordinate; 28 | 29 | /// Secret key management. 30 | #[cfg(feature = "encryption")] 31 | #[cfg_attr(docsrs, doc(cfg(feature = "encryption")))] 32 | pub mod key_manager; 33 | 34 | mod serf; 35 | pub use serf::*; 36 | 37 | mod snapshot; 38 | pub use snapshot::*; 39 | 40 | fn invalid_data_io_error(e: E) -> std::io::Error { 41 | std::io::Error::new(std::io::ErrorKind::InvalidData, e) 42 | } 43 | 44 | /// All unit test fns are exported in the `tests` module. 45 | /// This module is used for users want to use other async runtime, 46 | /// and want to use the test if memberlist also works with their runtime. 47 | #[cfg(feature = "test")] 48 | #[cfg_attr(docsrs, doc(cfg(feature = "test")))] 49 | pub mod tests { 50 | pub use memberlist_core::tests::{AnyError, next_socket_addr_v4, next_socket_addr_v6}; 51 | pub use paste; 52 | 53 | pub use super::serf::base::tests::{serf::*, *}; 54 | 55 | /// Add `test` prefix to the predefined unit test fn with a given [`Runtime`](memberlist_core::agnostic_lite::RuntimeLite) 56 | #[cfg(any(feature = "test", test))] 57 | #[cfg_attr(docsrs, doc(cfg(any(feature = "test", test))))] 58 | #[macro_export] 59 | macro_rules! unit_tests { 60 | ($runtime:ty => $run:ident($($fn:ident), +$(,)?)) => { 61 | $( 62 | ::serf_core::tests::paste::paste! { 63 | #[test] 64 | fn [< test_ $fn >] () { 65 | $run($fn::<$runtime>()); 66 | } 67 | } 68 | )* 69 | }; 70 | } 71 | 72 | /// Add `test` prefix to the predefined unit test fn with a given [`Runtime`](memberlist_core::agnostic_lite::RuntimeLite) 73 | #[cfg(any(feature = "test", test))] 74 | #[cfg_attr(docsrs, doc(cfg(any(feature = "test", test))))] 75 | #[macro_export] 76 | macro_rules! unit_tests_with_expr { 77 | ($run:ident($( 78 | $(#[$outer:meta])* 79 | $fn:ident( $expr:expr ) 80 | ), +$(,)?)) => { 81 | $( 82 | ::serf_core::tests::paste::paste! { 83 | #[test] 84 | $(#[$outer])* 85 | fn [< test_ $fn >] () { 86 | $run(async move { 87 | $expr 88 | }); 89 | } 90 | } 91 | )* 92 | }; 93 | } 94 | 95 | /// Initialize the tracing for the unit tests. 96 | pub fn initialize_tests_tracing() { 97 | use std::sync::Once; 98 | static TRACE: Once = Once::new(); 99 | TRACE.call_once(|| { 100 | let filter = std::env::var("SERF_TESTING_LOG") 101 | .unwrap_or_else(|_| "serf_core=debug,memberlist_core=info".to_owned()); 102 | memberlist_core::tracing::subscriber::set_global_default( 103 | tracing_subscriber::fmt::fmt() 104 | .without_time() 105 | .with_line_number(true) 106 | .with_env_filter(filter) 107 | .with_file(false) 108 | .with_target(true) 109 | .with_ansi(true) 110 | .finish(), 111 | ) 112 | .unwrap(); 113 | }); 114 | } 115 | 116 | /// Run the unit test with a given async runtime sequentially. 117 | pub fn run(block_on: B, fut: F) 118 | where 119 | B: FnOnce(F) -> F::Output, 120 | F: std::future::Future, 121 | { 122 | // initialize_tests_tracing(); 123 | block_on(fut); 124 | } 125 | } 126 | -------------------------------------------------------------------------------- /serf-core/src/types/tags.rs: -------------------------------------------------------------------------------- 1 | use indexmap::IndexMap; 2 | use memberlist_core::proto::{ 3 | Data, DataRef, DecodeError, EncodeError, RepeatedDecoder, TupleEncoder, WireType, 4 | utils::{merge, skip}, 5 | }; 6 | use smol_str::SmolStr; 7 | 8 | const TAGS_TAG: u8 = 1; 9 | const TAGS_BYTE: u8 = merge(WireType::LengthDelimited, TAGS_TAG); 10 | 11 | /// Tags of a node 12 | #[derive( 13 | Debug, 14 | Default, 15 | PartialEq, 16 | Clone, 17 | derive_more::From, 18 | derive_more::Into, 19 | derive_more::Deref, 20 | derive_more::DerefMut, 21 | derive_more::AsRef, 22 | derive_more::AsMut, 23 | derive_more::IntoIterator, 24 | )] 25 | #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] 26 | #[cfg_attr(feature = "serde", serde(transparent))] 27 | #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))] 28 | pub struct Tags( 29 | #[cfg_attr(feature = "arbitrary", arbitrary(with = crate::types::arbitrary_impl::arbitrary_indexmap))] 30 | IndexMap, 31 | ); 32 | 33 | impl FromIterator<(K, V)> for Tags 34 | where 35 | K: Into, 36 | V: Into, 37 | { 38 | fn from_iter>(iter: T) -> Self { 39 | Self( 40 | iter 41 | .into_iter() 42 | .map(|(k, v)| (k.into(), v.into())) 43 | .collect(), 44 | ) 45 | } 46 | } 47 | 48 | impl Tags { 49 | /// Create a new Tags 50 | #[inline] 51 | pub fn new() -> Self { 52 | Self(IndexMap::new()) 53 | } 54 | 55 | /// Create a new Tags with a capacity 56 | pub fn with_capacity(cap: usize) -> Self { 57 | Self(IndexMap::with_capacity(cap)) 58 | } 59 | } 60 | 61 | /// The reference type to [`Tags`], which is an iterator and yields a reference to the key and value 62 | #[derive(Clone, Copy, Debug, PartialEq, Eq)] 63 | pub struct TagsRef<'a> { 64 | src: RepeatedDecoder<'a>, 65 | } 66 | 67 | impl<'a> DataRef<'a, Tags> for TagsRef<'a> { 68 | fn decode(src: &'a [u8]) -> Result<(usize, Self), DecodeError> 69 | where 70 | Self: Sized, 71 | { 72 | let mut offset = 0; 73 | let buf_len = src.len(); 74 | 75 | let mut tags_offsets = None; 76 | let mut num_tags = 0; 77 | 78 | while offset < buf_len { 79 | match src[offset] { 80 | TAGS_BYTE => { 81 | let readed = skip("Tags", &src[offset..])?; 82 | if let Some((ref mut fnso, ref mut lnso)) = tags_offsets { 83 | if *fnso > offset { 84 | *fnso = offset; 85 | } 86 | 87 | if *lnso < offset + readed { 88 | *lnso = offset + readed; 89 | } 90 | } else { 91 | tags_offsets = Some((offset, offset + readed)); 92 | } 93 | num_tags += 1; 94 | offset += readed; 95 | } 96 | _ => offset += skip("Tags", &src[offset..])?, 97 | } 98 | } 99 | 100 | let decoder = 101 | RepeatedDecoder::new(TAGS_TAG, WireType::LengthDelimited, src).with_nums(num_tags); 102 | 103 | Ok(( 104 | offset, 105 | Self { 106 | src: if let Some((fnso, lnso)) = tags_offsets { 107 | decoder.with_offsets(fnso, lnso) 108 | } else { 109 | decoder 110 | }, 111 | }, 112 | )) 113 | } 114 | } 115 | 116 | impl Data for Tags { 117 | type Ref<'a> = TagsRef<'a>; 118 | 119 | fn from_ref(val: Self::Ref<'_>) -> Result 120 | where 121 | Self: Sized, 122 | { 123 | val 124 | .src 125 | .iter::<(SmolStr, SmolStr)>() 126 | .map(|res| res.and_then(Data::from_ref)) 127 | .collect::, DecodeError>>() 128 | .map(Self) 129 | } 130 | 131 | fn encoded_len(&self) -> usize { 132 | self 133 | .0 134 | .iter() 135 | .map(|(k, v)| 1 + TupleEncoder::new(k, v).encoded_len_with_length_delimited()) 136 | .sum::() 137 | } 138 | 139 | fn encode(&self, buf: &mut [u8]) -> Result { 140 | let buf_len = buf.len(); 141 | self 142 | .0 143 | .iter() 144 | .try_fold(0, |mut offset, (k, v)| { 145 | if offset >= buf_len { 146 | return Err(EncodeError::insufficient_buffer(1, 0)); 147 | } 148 | 149 | buf[offset] = TAGS_BYTE; 150 | offset += 1; 151 | offset += TupleEncoder::new(k, v).encode_with_length_delimited(&mut buf[offset..])?; 152 | Ok(offset) 153 | }) 154 | .map_err(|e: EncodeError| e.update(self.encoded_len(), buf.len())) 155 | } 156 | } 157 | -------------------------------------------------------------------------------- /serf-core/src/types/version.rs: -------------------------------------------------------------------------------- 1 | use memberlist_core::proto::{Data, DataRef, DecodeError, EncodeError, WireType}; 2 | 3 | /// Delegate version 4 | #[derive( 5 | Debug, Default, Copy, Clone, PartialEq, Eq, Hash, derive_more::IsVariant, derive_more::Display, 6 | )] 7 | #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] 8 | #[non_exhaustive] 9 | pub enum DelegateVersion { 10 | /// Version 1 11 | #[default] 12 | #[display("v1")] 13 | V1, 14 | /// Unknown version (used for forwards and backwards compatibility) 15 | #[display("unknown({_0})")] 16 | Unknown(u8), 17 | } 18 | 19 | impl From for DelegateVersion { 20 | fn from(v: u8) -> Self { 21 | match v { 22 | 1 => Self::V1, 23 | val => Self::Unknown(val), 24 | } 25 | } 26 | } 27 | 28 | impl From for u8 { 29 | fn from(v: DelegateVersion) -> Self { 30 | match v { 31 | DelegateVersion::V1 => 1, 32 | DelegateVersion::Unknown(val) => val, 33 | } 34 | } 35 | } 36 | 37 | /// Protocol version 38 | #[derive( 39 | Debug, Default, Copy, Clone, PartialEq, Eq, Hash, derive_more::IsVariant, derive_more::Display, 40 | )] 41 | #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] 42 | #[non_exhaustive] 43 | pub enum ProtocolVersion { 44 | /// Version 1 45 | #[default] 46 | #[display("v1")] 47 | V1, 48 | /// Unknown version (used for forwards and backwards compatibility) 49 | #[display("unknown({_0})")] 50 | Unknown(u8), 51 | } 52 | 53 | impl From for ProtocolVersion { 54 | fn from(v: u8) -> Self { 55 | match v { 56 | 1 => Self::V1, 57 | val => Self::Unknown(val), 58 | } 59 | } 60 | } 61 | 62 | impl From for u8 { 63 | fn from(v: ProtocolVersion) -> Self { 64 | match v { 65 | ProtocolVersion::V1 => 1, 66 | ProtocolVersion::Unknown(val) => val, 67 | } 68 | } 69 | } 70 | 71 | macro_rules! impl_data { 72 | ($($ty:ty),+$(,)?) => { 73 | $( 74 | impl<'a> DataRef<'a, Self> for $ty { 75 | fn decode(src: &'a [u8]) -> Result<(usize, Self), DecodeError> { 76 | if src.is_empty() { 77 | return Err(DecodeError::buffer_underflow()); 78 | } 79 | 80 | Ok((1, Self::from(src[0]))) 81 | } 82 | } 83 | 84 | impl Data for $ty { 85 | const WIRE_TYPE: WireType = WireType::Byte; 86 | 87 | type Ref<'a> = Self; 88 | 89 | fn from_ref(val: Self::Ref<'_>) -> Result { 90 | Ok(val) 91 | } 92 | 93 | #[inline] 94 | fn encoded_len(&self) -> usize { 95 | 1 96 | } 97 | 98 | #[inline] 99 | fn encode(&self, buf: &mut [u8]) -> Result { 100 | if buf.is_empty() { 101 | return Err(EncodeError::insufficient_buffer(1, 0)); 102 | } 103 | 104 | buf[0] = u8::from(*self); 105 | Ok(1) 106 | } 107 | } 108 | )* 109 | }; 110 | } 111 | 112 | impl_data!(DelegateVersion, ProtocolVersion); 113 | 114 | #[cfg(test)] 115 | mod tests { 116 | use super::*; 117 | 118 | #[cfg(feature = "arbitrary")] 119 | use arbitrary::{Arbitrary, Unstructured}; 120 | 121 | #[test] 122 | #[cfg(feature = "arbitrary")] 123 | fn test_delegate_version() { 124 | let mut buf = [0; 64]; 125 | rand::fill(&mut buf[..]); 126 | 127 | let mut data = Unstructured::new(&buf); 128 | let _ = DelegateVersion::arbitrary(&mut data).unwrap(); 129 | 130 | assert_eq!(u8::from(DelegateVersion::V1), 1u8); 131 | assert_eq!(DelegateVersion::V1.to_string(), "v1"); 132 | assert_eq!(DelegateVersion::Unknown(2).to_string(), "unknown(2)"); 133 | assert_eq!(DelegateVersion::from(1), DelegateVersion::V1); 134 | assert_eq!(DelegateVersion::from(2), DelegateVersion::Unknown(2)); 135 | } 136 | 137 | #[test] 138 | #[cfg(feature = "arbitrary")] 139 | fn test_protocol_version() { 140 | let mut buf = [0; 64]; 141 | rand::fill(&mut buf[..]); 142 | 143 | let mut data = Unstructured::new(&buf); 144 | let _ = ProtocolVersion::arbitrary(&mut data).unwrap(); 145 | assert_eq!(u8::from(ProtocolVersion::V1), 1); 146 | assert_eq!(ProtocolVersion::V1.to_string(), "v1"); 147 | assert_eq!(ProtocolVersion::Unknown(2).to_string(), "unknown(2)"); 148 | assert_eq!(ProtocolVersion::from(1), ProtocolVersion::V1); 149 | assert_eq!(ProtocolVersion::from(2), ProtocolVersion::Unknown(2)); 150 | } 151 | } 152 | -------------------------------------------------------------------------------- /serf/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "serf" 3 | version.workspace = true 4 | rust-version.workspace = true 5 | edition.workspace = true 6 | license.workspace = true 7 | description.workspace = true 8 | repository.workspace = true 9 | readme.workspace = true 10 | homepage.workspace = true 11 | keywords.workspace = true 12 | categories.workspace = true 13 | 14 | [package.metadata.docs.rs] 15 | all-features = true 16 | rustdoc-args = ["--cfg", "docsrs"] 17 | 18 | [features] 19 | default = ["tokio", "compression", "encryption", "dns", "tcp", "quic"] 20 | 21 | tokio = ["memberlist/tokio"] 22 | async-std = ["memberlist/async-std"] 23 | smol = ["memberlist/smol"] 24 | 25 | serde = [ 26 | "memberlist/serde", 27 | "serf-core/serde", 28 | ] 29 | 30 | metrics = [ 31 | "memberlist/metrics", 32 | "serf-core/metrics", 33 | ] 34 | 35 | compression = [] 36 | 37 | encryption = ["memberlist/encryption", "serf-core/encryption"] 38 | 39 | quic = ["memberlist/quic"] 40 | quinn = ["memberlist/quinn", "quic"] 41 | 42 | net = ["memberlist/net"] 43 | tcp = ["memberlist/tcp", "net"] 44 | tls = ["memberlist/tls", "net"] 45 | 46 | # enable DNS node address resolver 47 | dns = ["memberlist/dns"] 48 | dns-over-quic = [ 49 | "memberlist/dns-over-quic", 50 | ] 51 | dns-over-h3 = ["memberlist/dns-over-h3"] 52 | dns-over-https-rustls = [ 53 | "memberlist/dns-over-https-rustls", 54 | ] 55 | dns-over-rustls = [ 56 | "memberlist/dns-over-rustls", 57 | ] 58 | dns-over-openssl = [ 59 | "memberlist/dns-over-openssl", 60 | ] 61 | dns-over-native-tls = [ 62 | "memberlist/dns-over-native-tls", 63 | ] 64 | dns-webpki-roots = [ 65 | "memberlist/dns-webpki-roots", 66 | ] 67 | dns-native-certs = [ 68 | "memberlist/dns-native-certs", 69 | ] 70 | dnssec-openssl = [ 71 | "memberlist/dnssec-openssl", 72 | ] 73 | dnssec-ring = ["memberlist/dnssec-ring"] 74 | dnssec = ["memberlist/dnssec"] 75 | 76 | test = ["memberlist/test", "serf-core/test"] 77 | 78 | [dependencies] 79 | memberlist.workspace = true 80 | serf-core = { workspace = true, default-features = false } 81 | 82 | [dev-dependencies] 83 | tokio = { version = "1", features = ["full"] } 84 | smol_str = "0.3" 85 | paste = "1" 86 | 87 | [[test]] 88 | name = "main" 89 | path = "test/main.rs" 90 | required-features = ["test"] 91 | -------------------------------------------------------------------------------- /serf/README.md: -------------------------------------------------------------------------------- 1 | ../README.md -------------------------------------------------------------------------------- /serf/src/async_std.rs: -------------------------------------------------------------------------------- 1 | pub use memberlist::async_std::*; 2 | 3 | /// [`Serf`](super::Serf) type alias for using [`NetTransport`](memberlist::net::NetTransport) and [`Tcp`](memberlist::net::stream_layer::tcp::Tcp) stream layer with `async-std` runtime. 4 | #[cfg(all(any(feature = "tcp", feature = "tls",), not(target_family = "wasm")))] 5 | #[cfg_attr( 6 | docsrs, 7 | doc(cfg(all(any(feature = "tcp", feature = "tls",), not(target_family = "wasm")))) 8 | )] 9 | pub type AsyncStdTcpSerf = serf_core::Serf, D>; 10 | 11 | /// [`Serf`](super::Serf) type alias for using [`NetTransport`](memberlist::net::NetTransport) and [`Tls`](memberlist::net::stream_layer::tls::Tls) stream layer with `async-std` runtime. 12 | #[cfg(all(feature = "tls", not(target_family = "wasm")))] 13 | #[cfg_attr(docsrs, doc(cfg(all(feature = "tls", not(target_family = "wasm")))))] 14 | pub type AsyncStdTlsSerf = serf_core::Serf, D>; 15 | 16 | /// [`Serf`](super::Serf) type alias for using [`QuicTransport`](memberlist::quic::QuicTransport) and [`Quinn`](memberlist::quic::stream_layer::quinn::Quinn) stream layer with `async-std` runtime. 17 | #[cfg(all(feature = "quinn", not(target_family = "wasm")))] 18 | #[cfg_attr(docsrs, doc(cfg(all(feature = "quinn", not(target_family = "wasm")))))] 19 | pub type AsyncStdQuicSerf = serf_core::Serf, D>; 20 | -------------------------------------------------------------------------------- /serf/src/lib.rs: -------------------------------------------------------------------------------- 1 | #![doc = include_str!("../README.md")] 2 | #![doc(html_logo_url = "https://raw.githubusercontent.com/al8n/serf/main/art/logo_72x72.png")] 3 | #![forbid(unsafe_code)] 4 | #![deny(warnings, missing_docs)] 5 | #![allow(clippy::type_complexity)] 6 | #![cfg_attr(docsrs, feature(doc_cfg))] 7 | #![cfg_attr(docsrs, allow(unused_attributes))] 8 | 9 | pub use serf_core::*; 10 | 11 | pub use memberlist::{agnostic, transport}; 12 | 13 | #[cfg(feature = "net")] 14 | pub use memberlist::net; 15 | 16 | #[cfg(feature = "quic")] 17 | pub use memberlist::quic; 18 | 19 | /// [`Serf`] for `tokio` runtime. 20 | #[cfg(feature = "tokio")] 21 | #[cfg_attr(docsrs, doc(cfg(feature = "tokio")))] 22 | pub mod tokio; 23 | 24 | /// [`Serf`] for `async-std` runtime. 25 | #[cfg(feature = "async-std")] 26 | #[cfg_attr(docsrs, doc(cfg(feature = "async-std")))] 27 | pub mod async_std; 28 | 29 | /// [`Serf`] for `smol` runtime. 30 | #[cfg(feature = "smol")] 31 | #[cfg_attr(docsrs, doc(cfg(feature = "smol")))] 32 | pub mod smol; 33 | -------------------------------------------------------------------------------- /serf/src/smol.rs: -------------------------------------------------------------------------------- 1 | pub use memberlist::smol::*; 2 | 3 | /// [`Serf`](super::Serf) type alias for using [`NetTransport`](memberlist::net::NetTransport) and [`Tcp`](memberlist::net::stream_layer::tcp::Tcp) stream layer with `smol` runtime. 4 | #[cfg(all(any(feature = "tcp", feature = "tls",), not(target_family = "wasm")))] 5 | #[cfg_attr( 6 | docsrs, 7 | doc(cfg(all(any(feature = "tcp", feature = "tls",), not(target_family = "wasm")))) 8 | )] 9 | pub type SmolTcpSerf = serf_core::Serf, D>; 10 | 11 | /// [`Serf`](super::Serf) type alias for using [`NetTransport`](memberlist::net::NetTransport) and [`Tls`](memberlist::net::stream_layer::tls::Tls) stream layer with `smol` runtime. 12 | #[cfg(all(feature = "tls", not(target_family = "wasm")))] 13 | #[cfg_attr(docsrs, doc(cfg(all(feature = "tls", not(target_family = "wasm")))))] 14 | pub type SmolTlsSerf = serf_core::Serf, D>; 15 | 16 | /// [`Serf`](super::Serf) type alias for using [`QuicTransport`](memberlist::quic::QuicTransport) and [`Quinn`](memberlist::quic::stream_layer::quinn::Quinn) stream layer with `smol` runtime. 17 | #[cfg(all(feature = "quinn", not(target_family = "wasm")))] 18 | #[cfg_attr(docsrs, doc(cfg(all(feature = "quinn", not(target_family = "wasm")))))] 19 | pub type SmolQuicSerf = serf_core::Serf, D>; 20 | -------------------------------------------------------------------------------- /serf/src/tokio.rs: -------------------------------------------------------------------------------- 1 | pub use memberlist::tokio::*; 2 | 3 | /// [`Serf`](super::Serf) type alias for using [`NetTransport`](memberlist::net::NetTransport) and [`Tcp`](memberlist::net::stream_layer::tcp::Tcp) stream layer with `tokio` runtime. 4 | #[cfg(all(any(feature = "tcp", feature = "tls",), not(target_family = "wasm")))] 5 | #[cfg_attr( 6 | docsrs, 7 | doc(cfg(all(any(feature = "tcp", feature = "tls",), not(target_family = "wasm")))) 8 | )] 9 | pub type TokioTcpSerf = serf_core::Serf, D>; 10 | 11 | /// [`Serf`](super::Serf) type alias for using [`NetTransport`](memberlist::net::NetTransport) and [`Tls`](memberlist::net::stream_layer::tls::Tls) stream layer with `tokio` runtime. 12 | #[cfg(all(feature = "tls", not(target_family = "wasm")))] 13 | #[cfg_attr(docsrs, doc(cfg(all(feature = "tls", not(target_family = "wasm")))))] 14 | pub type TokioTlsSerf = serf_core::Serf, D>; 15 | 16 | /// [`Serf`](super::Serf) type alias for using [`QuicTransport`](memberlist::quic::QuicTransport) and [`Quinn`](memberlist::quic::stream_layer::quinn::Quinn) stream layer with `tokio` runtime. 17 | #[cfg(all(feature = "quinn", not(target_family = "wasm")))] 18 | #[cfg_attr(docsrs, doc(cfg(all(feature = "quinn", not(target_family = "wasm")))))] 19 | pub type TokioQuicSerf = serf_core::Serf, D>; 20 | -------------------------------------------------------------------------------- /serf/test/main.rs: -------------------------------------------------------------------------------- 1 | use core::future::Future; 2 | use serf_core::tests::run as run_unit_test; 3 | 4 | #[cfg(feature = "net")] 5 | #[path = "./main/net.rs"] 6 | mod net; 7 | 8 | #[cfg(feature = "tokio")] 9 | fn tokio_run(fut: impl Future) { 10 | let runtime = ::tokio::runtime::Builder::new_multi_thread() 11 | .worker_threads(32) 12 | .enable_all() 13 | .build() 14 | .unwrap(); 15 | run_unit_test(|fut| runtime.block_on(fut), fut) 16 | } 17 | 18 | #[cfg(feature = "smol")] 19 | fn smol_run(fut: impl Future) { 20 | use serf::agnostic::{RuntimeLite, smol::SmolRuntime}; 21 | run_unit_test(SmolRuntime::block_on, fut); 22 | } 23 | 24 | #[cfg(feature = "async-std")] 25 | fn async_std_run(fut: impl Future) { 26 | use serf::agnostic::{RuntimeLite, async_std::AsyncStdRuntime}; 27 | run_unit_test(AsyncStdRuntime::block_on, fut); 28 | } 29 | -------------------------------------------------------------------------------- /serf/test/main/net.rs: -------------------------------------------------------------------------------- 1 | #[path = "./net/delegate.rs"] 2 | mod delegate; 3 | 4 | #[path = "./net/event.rs"] 5 | mod event; 6 | 7 | #[path = "./net/leave.rs"] 8 | mod leave; 9 | 10 | #[path = "./net/reap.rs"] 11 | mod reap; 12 | 13 | #[path = "./net/reconnect.rs"] 14 | mod reconnect; 15 | 16 | #[path = "./net/remove.rs"] 17 | mod remove; 18 | 19 | #[path = "./net/snapshot.rs"] 20 | mod snapshot; 21 | 22 | #[path = "./net/update.rs"] 23 | mod update; 24 | 25 | #[path = "./net/role.rs"] 26 | mod role; 27 | 28 | #[path = "./net/set_tags.rs"] 29 | mod set_tags; 30 | 31 | #[path = "./net/get_queue_max.rs"] 32 | mod get_queue_max; 33 | 34 | #[path = "./net/local_member.rs"] 35 | mod local_member; 36 | 37 | #[path = "./net/num_nodes.rs"] 38 | mod num_nodes; 39 | 40 | #[path = "./net/state.rs"] 41 | mod state; 42 | 43 | #[path = "./net/stats.rs"] 44 | mod stats; 45 | 46 | #[path = "./net/coordinates.rs"] 47 | mod coordinates; 48 | 49 | #[path = "./net/name_resolution.rs"] 50 | mod name_resolution; 51 | 52 | #[path = "./net/join.rs"] 53 | mod join; 54 | 55 | #[cfg(feature = "encryption")] 56 | #[path = "./net/write_keyring_file.rs"] 57 | mod write_keyring_file; 58 | -------------------------------------------------------------------------------- /serf/test/main/net/coordinates.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{serf_coordinates, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_coordinates_v4() { 19 | let name = "serf_coordinates1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_coordinates2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | let name = "serf_coordinates3_v4"; 28 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 29 | opts3.add_bind_address(next_socket_addr_v4(0)); 30 | 31 | [< $rt:snake _run >](serf_coordinates::< 32 | NetTransport< 33 | SmolStr, 34 | SocketAddrResolver<[< $rt:camel Runtime >]>, 35 | Tcp<[< $rt:camel Runtime >]>, 36 | 37 | [< $rt:camel Runtime >], 38 | >, 39 | >(opts, opts2, opts3)); 40 | } 41 | 42 | #[test] 43 | fn test_serf_coordinates_v6() { 44 | let name = "serf_coordinates1_v6"; 45 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 46 | opts.add_bind_address(next_socket_addr_v6()); 47 | 48 | let name = "serf_coordinates2_v6"; 49 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 50 | opts2.add_bind_address(next_socket_addr_v6()); 51 | 52 | let name = "serf_coordinates3_v6"; 53 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 54 | opts3.add_bind_address(next_socket_addr_v6()); 55 | 56 | [< $rt:snake _run >](serf_coordinates::< 57 | NetTransport< 58 | SmolStr, 59 | SocketAddrResolver<[< $rt:camel Runtime >]>, 60 | Tcp<[< $rt:camel Runtime >]>, 61 | 62 | [< $rt:camel Runtime >], 63 | >, 64 | >(opts, opts2, opts3)); 65 | } 66 | } 67 | } 68 | }; 69 | } 70 | 71 | #[cfg(feature = "tokio")] 72 | test_mod!(tokio); 73 | 74 | #[cfg(feature = "async-std")] 75 | test_mod!(async_std); 76 | 77 | #[cfg(feature = "smol")] 78 | test_mod!(smol); 79 | -------------------------------------------------------------------------------- /serf/test/main/net/delegate.rs: -------------------------------------------------------------------------------- 1 | #[path = "./delegate/nodemeta.rs"] 2 | mod nodemeta; 3 | 4 | #[path = "./delegate/local_state.rs"] 5 | mod local_state; 6 | 7 | #[path = "./delegate/remote_state.rs"] 8 | mod remote_state; 9 | 10 | #[path = "./delegate/ping_delegate.rs"] 11 | mod ping_delegate; 12 | -------------------------------------------------------------------------------- /serf/test/main/net/delegate/local_state.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{delegate::delegate_local_state, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_delegate_local_state_v4() { 19 | let name = "delegate_nodemeta_local_state1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "delegate_nodemeta_local_state2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](delegate_local_state::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | [< $rt:camel Runtime >], 33 | >, 34 | >(opts, opts2)); 35 | } 36 | 37 | #[test] 38 | fn test_delegate_local_state_v6() { 39 | let name = "delegate_nodemeta_local_state1_v6"; 40 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 41 | opts.add_bind_address(next_socket_addr_v6()); 42 | 43 | let name = "delegate_nodemeta_local_state2_v6"; 44 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 45 | opts2.add_bind_address(next_socket_addr_v6()); 46 | 47 | [< $rt:snake _run >](delegate_local_state::< 48 | NetTransport< 49 | SmolStr, 50 | SocketAddrResolver<[< $rt:camel Runtime >]>, 51 | Tcp<[< $rt:camel Runtime >]>, 52 | 53 | [< $rt:camel Runtime >], 54 | >, 55 | >(opts, opts2)); 56 | } 57 | } 58 | } 59 | }; 60 | } 61 | 62 | #[cfg(feature = "tokio")] 63 | test_mod!(tokio); 64 | 65 | #[cfg(feature = "async-std")] 66 | test_mod!(async_std); 67 | 68 | #[cfg(feature = "smol")] 69 | test_mod!(smol); 70 | -------------------------------------------------------------------------------- /serf/test/main/net/delegate/nodemeta.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{delegate::{delegate_nodemeta, delegate_nodemeta_panic}, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_delegate_nodemeta_v4() { 19 | let name = "delegate_nodemeta_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | [< $rt:snake _run >](delegate_nodemeta::< 23 | NetTransport< 24 | SmolStr, 25 | SocketAddrResolver<[< $rt:camel Runtime >]>, 26 | Tcp<[< $rt:camel Runtime >]>, 27 | 28 | [< $rt:camel Runtime >], 29 | >, 30 | >(opts)); 31 | } 32 | 33 | #[test] 34 | fn test_delegate_nodemeta_v6() { 35 | let name = "delegate_nodemeta_v6"; 36 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 37 | opts.add_bind_address(next_socket_addr_v6()); 38 | [< $rt:snake _run >](delegate_nodemeta::< 39 | NetTransport< 40 | SmolStr, 41 | SocketAddrResolver<[< $rt:camel Runtime >]>, 42 | Tcp<[< $rt:camel Runtime >]>, 43 | 44 | [< $rt:camel Runtime >], 45 | >, 46 | >(opts)); 47 | } 48 | 49 | #[test] 50 | #[should_panic] 51 | fn test_delegate_nodemeta_panic_v4() { 52 | let name = "delegate_nodemeta_panic_v4"; 53 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 54 | opts.add_bind_address(next_socket_addr_v4(0)); 55 | [< $rt:snake _run >](delegate_nodemeta_panic::< 56 | NetTransport< 57 | SmolStr, 58 | SocketAddrResolver<[< $rt:camel Runtime >]>, 59 | Tcp<[< $rt:camel Runtime >]>, 60 | 61 | [< $rt:camel Runtime >], 62 | >, 63 | >(opts)); 64 | } 65 | 66 | #[test] 67 | #[should_panic] 68 | fn test_delegate_nodemeta_panic_v6() { 69 | let name = "delegate_nodemeta_panic_v6"; 70 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 71 | opts.add_bind_address(next_socket_addr_v6()); 72 | [< $rt:snake _run >](delegate_nodemeta_panic::< 73 | NetTransport< 74 | SmolStr, 75 | SocketAddrResolver<[< $rt:camel Runtime >]>, 76 | Tcp<[< $rt:camel Runtime >]>, 77 | 78 | [< $rt:camel Runtime >], 79 | >, 80 | >(opts)); 81 | } 82 | } 83 | } 84 | }; 85 | } 86 | 87 | #[cfg(feature = "tokio")] 88 | test_mod!(tokio); 89 | 90 | #[cfg(feature = "async-std")] 91 | test_mod!(async_std); 92 | 93 | #[cfg(feature = "smol")] 94 | test_mod!(smol); 95 | -------------------------------------------------------------------------------- /serf/test/main/net/delegate/ping_delegate.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{delegate::{serf_ping_delegate_versioning, serf_ping_delegate_rogue_coordinate}, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_ping_delegate_versioning_v4() { 19 | let name = "serf_ping_delegate_versioning1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_ping_delegate_versioning2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_ping_delegate_versioning::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_delegate_serf_ping_delegate_versioning_v6() { 40 | let name = "serf_ping_delegate_versioning1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_ping_delegate_versioning2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_ping_delegate_versioning::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | 59 | #[test] 60 | fn test_serf_ping_delegate_rogue_coordinate_v4() { 61 | let name = "serf_ping_delegate_rogue_coordinate1_v4"; 62 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 63 | opts.add_bind_address(next_socket_addr_v4(0)); 64 | 65 | let name = "serf_ping_delegate_rogue_coordinate2_v4"; 66 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 67 | opts2.add_bind_address(next_socket_addr_v4(0)); 68 | 69 | [< $rt:snake _run >](serf_ping_delegate_rogue_coordinate::< 70 | NetTransport< 71 | SmolStr, 72 | SocketAddrResolver<[< $rt:camel Runtime >]>, 73 | Tcp<[< $rt:camel Runtime >]>, 74 | 75 | [< $rt:camel Runtime >], 76 | >, 77 | >(opts, opts2)); 78 | } 79 | 80 | #[test] 81 | fn test_serf_ping_delegate_rogue_coordinate_v6() { 82 | let name = "serf_ping_delegate_rogue_coordinate1_v6"; 83 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 84 | opts.add_bind_address(next_socket_addr_v6()); 85 | 86 | let name = "serf_ping_delegate_rogue_coordinate2_v6"; 87 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 88 | opts2.add_bind_address(next_socket_addr_v6()); 89 | 90 | [< $rt:snake _run >](serf_ping_delegate_rogue_coordinate::< 91 | NetTransport< 92 | SmolStr, 93 | SocketAddrResolver<[< $rt:camel Runtime >]>, 94 | Tcp<[< $rt:camel Runtime >]>, 95 | 96 | [< $rt:camel Runtime >], 97 | >, 98 | >(opts, opts2)); 99 | } 100 | } 101 | } 102 | }; 103 | } 104 | 105 | #[cfg(feature = "tokio")] 106 | test_mod!(tokio); 107 | 108 | #[cfg(feature = "async-std")] 109 | test_mod!(async_std); 110 | 111 | #[cfg(feature = "smol")] 112 | test_mod!(smol); 113 | -------------------------------------------------------------------------------- /serf/test/main/net/delegate/remote_state.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{delegate::delegate_merge_remote_state, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_delegate_merge_remote_state_v4() { 19 | let name = "delegate_nodemeta_merge_remote_state_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](delegate_merge_remote_state::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts)); 32 | } 33 | 34 | #[test] 35 | fn test_delegate_merge_remote_state_v6() { 36 | let name = "delegate_nodemeta_merge_remote_state_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](delegate_merge_remote_state::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts)); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/event.rs: -------------------------------------------------------------------------------- 1 | #[path = "./event/default_query.rs"] 2 | mod default_query; 3 | 4 | #[path = "./event/event_user_size_limit.rs"] 5 | mod event_user_size_limit; 6 | 7 | #[path = "./event/event_user.rs"] 8 | mod event_user; 9 | 10 | #[path = "./event/events_failed.rs"] 11 | mod events_failed; 12 | 13 | #[path = "./event/events_join.rs"] 14 | mod events_join; 15 | 16 | #[path = "./event/events_leave_avoid_infinite_rebroadcast.rs"] 17 | mod events_leave_avoid_infinite_rebroadcast; 18 | 19 | #[path = "./event/events_leave.rs"] 20 | mod events_leave; 21 | 22 | #[path = "./event/query_deduplicate.rs"] 23 | mod query_deduplicate; 24 | 25 | #[path = "./event/query_filter.rs"] 26 | mod query_filter; 27 | 28 | #[path = "./event/query_old_message.rs"] 29 | mod query_old_message; 30 | 31 | #[path = "./event/query.rs"] 32 | mod query; 33 | 34 | #[path = "./event/query_same_clock.rs"] 35 | mod query_same_clock; 36 | 37 | #[path = "./event/query_size_limit.rs"] 38 | mod query_size_limit; 39 | 40 | #[path = "./event/query_size_limit_increased.rs"] 41 | mod query_size_limit_increased; 42 | 43 | #[path = "./event/remove_failed_events_leave.rs"] 44 | mod remove_failed_events_leave; 45 | 46 | #[path = "./event/should_process.rs"] 47 | mod should_process; 48 | 49 | #[path = "./event/user_event_old_message.rs"] 50 | mod user_event_old_message; 51 | 52 | #[path = "./event/user_event_same_clock.rs"] 53 | mod user_event_same_clock; 54 | -------------------------------------------------------------------------------- /serf/test/main/net/event/default_query.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{event::default_query, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_default_query_v4() { 19 | let name = "default_query_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](default_query::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts)); 32 | } 33 | 34 | #[test] 35 | fn test_default_query_v6() { 36 | let name = "default_query_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](default_query::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts)); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/event/event_user.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{event::serf_event_user, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_event_user_v4() { 19 | let name = "serf_event_user1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_event_user2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_event_user::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_serf_event_user_v6() { 40 | let name = "serf_event_user1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_event_user2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_event_user::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/event/event_user_size_limit.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{event::serf_event_user_size_limit, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_event_user_size_limit_v4() { 19 | let name = "serf_event_user_size_limit_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](serf_event_user_size_limit::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts)); 32 | } 33 | 34 | #[test] 35 | fn test_serf_event_user_size_limit_v6() { 36 | let name = "serf_event_user_size_limit_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](serf_event_user_size_limit::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts)); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/event/events_failed.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{event::serf_events_failed, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_events_failed_v4() { 19 | let name = "serf_events_failed1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_events_failed2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_events_failed::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_serf_events_failed_v6() { 40 | let name = "serf_events_failed1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_events_failed2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_events_failed::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/event/events_join.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{event::serf_events_join, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_events_join_v4() { 19 | let name = "serf_events_join1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_events_join2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_events_join::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_serf_events_join_v6() { 40 | let name = "serf_events_join1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_events_join2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_events_join::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/event/events_leave.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{event::serf_events_leave, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_events_leave_v4() { 19 | let name = "serf_events_leave1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_events_leave2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_events_leave::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_serf_events_leave_v6() { 40 | let name = "serf_events_leave1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_events_leave2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_events_leave::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/event/events_leave_avoid_infinite_rebroadcast.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{event::serf_events_leave_avoid_infinite_rebroadcast, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_events_leave_avoid_infinite_rebroadcast_v4() { 19 | let name = "serf_events_leave_avoid_infinite_rebroadcast1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_events_leave_avoid_infinite_rebroadcast2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | let name = "serf_events_leave_avoid_infinite_rebroadcast3_v4"; 28 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 29 | opts3.add_bind_address(next_socket_addr_v4(0)); 30 | 31 | let name = "serf_events_leave_avoid_infinite_rebroadcast4_v4"; 32 | let mut opts4 = NetTransportOptions::new(SmolStr::new(name)); 33 | opts4.add_bind_address(next_socket_addr_v4(0)); 34 | 35 | [< $rt:snake _run >](serf_events_leave_avoid_infinite_rebroadcast::< 36 | NetTransport< 37 | SmolStr, 38 | SocketAddrResolver<[< $rt:camel Runtime >]>, 39 | Tcp<[< $rt:camel Runtime >]>, 40 | 41 | [< $rt:camel Runtime >], 42 | >, 43 | _, 44 | >(opts, opts2, opts3, opts4, |id, addr| async move { 45 | let mut opts2 = NetTransportOptions::new(id); 46 | opts2.add_bind_address(addr); 47 | opts2 48 | })); 49 | } 50 | 51 | #[test] 52 | fn test_serf_events_leave_avoid_infinite_rebroadcast_v6() { 53 | let name = "serf_events_leave_avoid_infinite_rebroadcast1_v6"; 54 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 55 | opts.add_bind_address(next_socket_addr_v6()); 56 | 57 | let name = "serf_events_leave_avoid_infinite_rebroadcast2_v6"; 58 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 59 | opts2.add_bind_address(next_socket_addr_v6()); 60 | 61 | let name = "serf_events_leave_avoid_infinite_rebroadcast3_v6"; 62 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 63 | opts3.add_bind_address(next_socket_addr_v6()); 64 | 65 | let name = "serf_events_leave_avoid_infinite_rebroadcast4_v6"; 66 | let mut opts4 = NetTransportOptions::new(SmolStr::new(name)); 67 | opts4.add_bind_address(next_socket_addr_v6()); 68 | 69 | [< $rt:snake _run >](serf_events_leave_avoid_infinite_rebroadcast::< 70 | NetTransport< 71 | SmolStr, 72 | SocketAddrResolver<[< $rt:camel Runtime >]>, 73 | Tcp<[< $rt:camel Runtime >]>, 74 | 75 | [< $rt:camel Runtime >], 76 | >, 77 | _, 78 | >(opts, opts2, opts3, opts4, |id, addr| async move { 79 | let mut opts2 = NetTransportOptions::new(id); 80 | opts2.add_bind_address(addr); 81 | opts2 82 | })); 83 | } 84 | } 85 | } 86 | }; 87 | } 88 | 89 | #[cfg(feature = "tokio")] 90 | test_mod!(tokio); 91 | 92 | #[cfg(feature = "async-std")] 93 | test_mod!(async_std); 94 | 95 | #[cfg(feature = "smol")] 96 | test_mod!(smol); 97 | -------------------------------------------------------------------------------- /serf/test/main/net/event/query.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{event::serf_query, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_query_v4() { 19 | let name = "serf_query1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_query2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_query::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_serf_query_v6() { 40 | let name = "serf_query1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_query2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_query::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/event/query_deduplicate.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{event::serf_query_deduplicate, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_query_deduplicate_v4() { 19 | let name = "serf_query_deduplicate_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](serf_query_deduplicate::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts)); 32 | } 33 | 34 | #[test] 35 | fn test_serf_query_deduplicate_v6() { 36 | let name = "serf_query_deduplicate_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](serf_query_deduplicate::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts)); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/event/query_filter.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{event::serf_query_filter, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_query_filter_v4() { 19 | let name = "serf_query_filter1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_query_filter2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | let name = "serf_query_filter3_v4"; 28 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 29 | opts3.add_bind_address(next_socket_addr_v4(0)); 30 | 31 | [< $rt:snake _run >](serf_query_filter::< 32 | NetTransport< 33 | SmolStr, 34 | SocketAddrResolver<[< $rt:camel Runtime >]>, 35 | Tcp<[< $rt:camel Runtime >]>, 36 | 37 | [< $rt:camel Runtime >], 38 | >, 39 | >(opts, opts2, opts3)); 40 | } 41 | 42 | #[test] 43 | fn test_serf_query_filter_v6() { 44 | let name = "serf_query_filter1_v6"; 45 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 46 | opts.add_bind_address(next_socket_addr_v6()); 47 | 48 | let name = "serf_query_filter2_v6"; 49 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 50 | opts2.add_bind_address(next_socket_addr_v6()); 51 | 52 | let name = "serf_query_filter3_v6"; 53 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 54 | opts3.add_bind_address(next_socket_addr_v6()); 55 | 56 | [< $rt:snake _run >](serf_query_filter::< 57 | NetTransport< 58 | SmolStr, 59 | SocketAddrResolver<[< $rt:camel Runtime >]>, 60 | Tcp<[< $rt:camel Runtime >]>, 61 | 62 | [< $rt:camel Runtime >], 63 | >, 64 | >(opts, opts2, opts3)); 65 | } 66 | } 67 | } 68 | }; 69 | } 70 | 71 | #[cfg(feature = "tokio")] 72 | test_mod!(tokio); 73 | 74 | #[cfg(feature = "async-std")] 75 | test_mod!(async_std); 76 | 77 | #[cfg(feature = "smol")] 78 | test_mod!(smol); 79 | -------------------------------------------------------------------------------- /serf/test/main/net/event/query_old_message.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | transport::Node, 13 | }; 14 | use serf_core::tests::{event::query_old_message, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_query_old_message_v4() { 19 | let name = "query_old_message_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](query_old_message::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, Node::new("fake1".into(), next_socket_addr_v4(0)))); 32 | } 33 | 34 | #[test] 35 | fn test_query_old_message_v6() { 36 | let name = "query_old_message_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](query_old_message::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts, Node::new("fake1".into(), next_socket_addr_v4(0)))); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/event/query_same_clock.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | transport::Node, 13 | }; 14 | use serf_core::tests::{event::query_same_clock, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_query_same_clock_v4() { 19 | let name = "query_same_clock_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](query_same_clock::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, Node::new("fake1".into(), next_socket_addr_v4(0)))); 32 | } 33 | 34 | #[test] 35 | fn test_query_same_clock_v6() { 36 | let name = "query_same_clock_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](query_same_clock::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts, Node::new("fake1".into(), next_socket_addr_v4(0)))); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/event/query_size_limit.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{event::serf_query_size_limit, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_query_size_limit_v4() { 19 | let name = "serf_query_size_limit_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](serf_query_size_limit::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts)); 32 | } 33 | 34 | #[test] 35 | fn test_serf_query_size_limit_v6() { 36 | let name = "serf_query_size_limit_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](serf_query_size_limit::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts)); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/event/query_size_limit_increased.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | 6 | use crate::[< $rt:snake _run >]; 7 | use serf::{ 8 | net::{ 9 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 10 | NetTransportOptions, 11 | }, 12 | [< $rt:snake >]::[< $rt:camel Runtime >], 13 | 14 | }; 15 | use serf_core::tests::{event::serf_query_size_limit_increased, next_socket_addr_v4, next_socket_addr_v6}; 16 | use smol_str::SmolStr; 17 | 18 | #[test] 19 | fn test_serf_query_size_limit_increased_v4() { 20 | let name = "serf_query_size_limit_increased_v4"; 21 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 22 | opts.add_bind_address(next_socket_addr_v4(0)); 23 | 24 | [< $rt:snake _run >](serf_query_size_limit_increased::< 25 | NetTransport< 26 | SmolStr, 27 | SocketAddrResolver<[< $rt:camel Runtime >]>, 28 | Tcp<[< $rt:camel Runtime >]>, 29 | 30 | [< $rt:camel Runtime >], 31 | >, 32 | >(opts)); 33 | } 34 | 35 | #[test] 36 | fn test_serf_query_size_limit_increased_v6() { 37 | let name = "serf_query_size_limit_increased_v6"; 38 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 39 | opts.add_bind_address(next_socket_addr_v6()); 40 | 41 | [< $rt:snake _run >](serf_query_size_limit_increased::< 42 | NetTransport< 43 | SmolStr, 44 | SocketAddrResolver<[< $rt:camel Runtime >]>, 45 | Tcp<[< $rt:camel Runtime >]>, 46 | 47 | [< $rt:camel Runtime >], 48 | >, 49 | >(opts)); 50 | } 51 | } 52 | } 53 | }; 54 | } 55 | 56 | #[cfg(feature = "tokio")] 57 | test_mod!(tokio); 58 | 59 | #[cfg(feature = "async-std")] 60 | test_mod!(async_std); 61 | 62 | #[cfg(feature = "smol")] 63 | test_mod!(smol); 64 | -------------------------------------------------------------------------------- /serf/test/main/net/event/remove_failed_events_leave.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{event::serf_remove_failed_events_leave, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_remove_failed_events_leave_v4() { 19 | let name = "serf_remove_failed_events_leave1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_remove_failed_events_leave2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_remove_failed_events_leave::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_serf_remove_failed_events_leave_v6() { 40 | let name = "serf_remove_failed_events_leave1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_remove_failed_events_leave2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_remove_failed_events_leave::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/event/should_process.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{event::should_process, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_should_process_v4() { 19 | let name = "should_process_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](should_process::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts)); 32 | } 33 | 34 | #[test] 35 | fn test_should_process_v6() { 36 | let name = "should_process_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](should_process::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts)); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/event/user_event_old_message.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{event::user_event_old_message, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_user_event_old_message_v4() { 19 | let name = "user_event_old_message_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](user_event_old_message::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts)); 32 | } 33 | 34 | #[test] 35 | fn test_user_event_old_message_v6() { 36 | let name = "user_event_old_message_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](user_event_old_message::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts)); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/event/user_event_same_clock.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{event::user_event_same_clock, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_user_event_same_clock_v4() { 19 | let name = "user_event_same_clock_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](user_event_same_clock::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts)); 32 | } 33 | 34 | #[test] 35 | fn test_user_event_same_clock_v6() { 36 | let name = "user_event_same_clock_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](user_event_same_clock::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts)); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/get_queue_max.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{serf_get_queue_max, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_get_queue_max_v4() { 19 | let name = "serf_get_queue_max_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](serf_get_queue_max::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, |idx| { 32 | format!("127.0.0.1:{idx}").parse().unwrap() 33 | })); 34 | } 35 | 36 | #[test] 37 | fn test_serf_get_queue_max_v6() { 38 | let name = "serf_get_queue_max_v6"; 39 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 40 | opts.add_bind_address(next_socket_addr_v6()); 41 | 42 | [< $rt:snake _run >](serf_get_queue_max::< 43 | NetTransport< 44 | SmolStr, 45 | SocketAddrResolver<[< $rt:camel Runtime >]>, 46 | Tcp<[< $rt:camel Runtime >]>, 47 | 48 | [< $rt:camel Runtime >], 49 | >, 50 | >(opts, |idx| { 51 | format!("127.0.0.1:{idx}").parse().unwrap() 52 | })); 53 | } 54 | } 55 | } 56 | }; 57 | } 58 | 59 | #[cfg(feature = "tokio")] 60 | test_mod!(tokio); 61 | 62 | #[cfg(feature = "async-std")] 63 | test_mod!(async_std); 64 | 65 | #[cfg(feature = "smol")] 66 | test_mod!(smol); 67 | -------------------------------------------------------------------------------- /serf/test/main/net/join.rs: -------------------------------------------------------------------------------- 1 | #[path = "./join/intent_buffer_early.rs"] 2 | mod intent_buffer_early; 3 | 4 | #[path = "./join/intent_newer.rs"] 5 | mod intent_newer; 6 | 7 | #[path = "./join/intent_old_message.rs"] 8 | mod intent_old_message; 9 | 10 | #[path = "./join/intent_reset_leaving.rs"] 11 | mod intent_reset_leaving; 12 | 13 | #[path = "./join/join_cancel.rs"] 14 | mod join_cancel; 15 | 16 | #[path = "./join/join_ignore_old.rs"] 17 | mod join_ignore_old; 18 | 19 | #[path = "./join/join_leave_join.rs"] 20 | mod join_leave_join; 21 | 22 | #[path = "./join/join_leave.rs"] 23 | mod join_leave; 24 | 25 | #[path = "./join/leave_ltime.rs"] 26 | mod leave_ltime; 27 | 28 | #[path = "./join/pending_intent.rs"] 29 | mod pending_intent; 30 | 31 | #[path = "./join/pending_intents.rs"] 32 | mod pending_intents; 33 | -------------------------------------------------------------------------------- /serf/test/main/net/join/intent_buffer_early.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{join::join_intent_buffer_early, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_join_intent_buffer_early_v4() { 19 | let name = "join_intent_buffer_early_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](join_intent_buffer_early::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts)); 32 | } 33 | 34 | #[test] 35 | fn test_join_intent_buffer_early_v6() { 36 | let name = "join_intent_buffer_early_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](join_intent_buffer_early::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts)); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/join/intent_newer.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{join::join_intent_newer, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_join_intent_newer_v4() { 19 | let name = "join_intent_newer_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](join_intent_newer::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, next_socket_addr_v4(0))); 32 | } 33 | 34 | #[test] 35 | fn test_join_intent_newer_v6() { 36 | let name = "join_intent_newer_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](join_intent_newer::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts, next_socket_addr_v6())); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/join/intent_old_message.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{join::join_intent_old_message, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_join_intent_old_message_v4() { 19 | let name = "join_intent_old_message_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](join_intent_old_message::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, next_socket_addr_v4(0))); 32 | } 33 | 34 | #[test] 35 | fn test_join_intent_old_message_v6() { 36 | let name = "join_intent_old_message_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](join_intent_old_message::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts, next_socket_addr_v6())); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/join/intent_reset_leaving.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{join::join_intent_reset_leaving, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_join_intent_reset_leaving_v4() { 19 | let name = "join_intent_reset_leaving_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](join_intent_reset_leaving::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, next_socket_addr_v4(0))); 32 | } 33 | 34 | #[test] 35 | fn test_join_intent_reset_leaving_v6() { 36 | let name = "join_intent_reset_leaving_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](join_intent_reset_leaving::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts, next_socket_addr_v6())); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/join/join_cancel.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{join::serf_join_cancel, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_join_cancel_v4() { 19 | let name = "serf_join_cancel1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_join_cancel2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_join_cancel::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_serf_join_cancel_v6() { 40 | let name = "serf_join_cancel1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_join_cancel2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_join_cancel::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/join/join_ignore_old.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{join::serf_join_ignore_old, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_join_ignore_old_v4() { 19 | let name = "serf_join_ignore_old1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_join_ignore_old2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_join_ignore_old::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_serf_join_ignore_old_v6() { 40 | let name = "serf_join_ignore_old1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_join_ignore_old2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_join_ignore_old::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/join/join_leave.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{join::serf_join_leave, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_join_leave_v4() { 19 | let name = "serf_join_leave1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_join_leave2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_join_leave::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_serf_join_leave_v6() { 40 | let name = "serf_join_leave1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_join_leave2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_join_leave::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/join/join_leave_join.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{join::serf_join_leave_join, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_join_leave_join_v4() { 19 | let name = "serf_join_leave_join1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_join_leave_join2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_join_leave_join::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_serf_join_leave_join_v6() { 40 | let name = "serf_join_leave_join1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_join_leave_join2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_join_leave_join::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/join/leave_ltime.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{join::join_leave_ltime, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_join_leave_ltime_v4() { 19 | let name = "join_leave_ltime1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "join_leave_ltime2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](join_leave_ltime::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_join_leave_ltime_v6() { 40 | let name = "join_leave_ltime1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "join_leave_ltime2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](join_leave_ltime::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/join/pending_intent.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{join::join_pending_intent, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_join_pending_intent_v4() { 19 | let name = "join_pending_intent_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](join_pending_intent::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, next_socket_addr_v4(0))); 32 | } 33 | 34 | #[test] 35 | fn test_join_pending_intent_v6() { 36 | let name = "join_pending_intent_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](join_pending_intent::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts, next_socket_addr_v6())); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/join/pending_intents.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{join::join_pending_intents, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_join_pending_intents_v4() { 19 | let name = "join_pending_intents_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](join_pending_intents::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, next_socket_addr_v4(0))); 32 | } 33 | 34 | #[test] 35 | fn test_join_pending_intents_v6() { 36 | let name = "join_pending_intents_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](join_pending_intents::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts, next_socket_addr_v6())); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/leave.rs: -------------------------------------------------------------------------------- 1 | #[path = "./leave/force_leave_failed.rs"] 2 | mod force_leave_failed; 3 | 4 | #[path = "./leave/force_leave_leaving.rs"] 5 | mod force_leave_leaving; 6 | 7 | #[path = "./leave/force_leave_left.rs"] 8 | mod force_leave_left; 9 | 10 | #[path = "./leave/intent_buffer_early.rs"] 11 | mod intent_buffer_early; 12 | 13 | #[path = "./leave/intent_newer.rs"] 14 | mod intent_newer; 15 | 16 | #[path = "./leave/intent_old_message.rs"] 17 | mod intent_old_message; 18 | 19 | #[path = "./leave/rejoin_different_role.rs"] 20 | mod rejoin_different_role; 21 | 22 | #[path = "./leave/snapshot_recovery.rs"] 23 | mod snapshot_recovery; 24 | -------------------------------------------------------------------------------- /serf/test/main/net/leave/force_leave_failed.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{leave::serf_force_leave_failed, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_force_leave_failed_v4() { 19 | let name = "serf_force_leave_failed1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_force_leave_failed2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | let name = "serf_force_leave_failed3_v4"; 28 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 29 | opts3.add_bind_address(next_socket_addr_v4(0)); 30 | 31 | [< $rt:snake _run >](serf_force_leave_failed::< 32 | NetTransport< 33 | SmolStr, 34 | SocketAddrResolver<[< $rt:camel Runtime >]>, 35 | Tcp<[< $rt:camel Runtime >]>, 36 | 37 | [< $rt:camel Runtime >], 38 | >, 39 | >(opts, opts2, opts3)); 40 | } 41 | 42 | #[test] 43 | fn test_serf_force_leave_failed_v6() { 44 | let name = "serf_force_leave_failed1_v6"; 45 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 46 | opts.add_bind_address(next_socket_addr_v6()); 47 | 48 | let name = "serf_force_leave_failed2_v6"; 49 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 50 | opts2.add_bind_address(next_socket_addr_v6()); 51 | 52 | let name = "serf_force_leave_failed3_v6"; 53 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 54 | opts3.add_bind_address(next_socket_addr_v6()); 55 | 56 | [< $rt:snake _run >](serf_force_leave_failed::< 57 | NetTransport< 58 | SmolStr, 59 | SocketAddrResolver<[< $rt:camel Runtime >]>, 60 | Tcp<[< $rt:camel Runtime >]>, 61 | 62 | [< $rt:camel Runtime >], 63 | >, 64 | >(opts, opts2, opts3)); 65 | } 66 | } 67 | } 68 | }; 69 | } 70 | 71 | #[cfg(feature = "tokio")] 72 | test_mod!(tokio); 73 | 74 | #[cfg(feature = "async-std")] 75 | test_mod!(async_std); 76 | 77 | #[cfg(feature = "smol")] 78 | test_mod!(smol); 79 | -------------------------------------------------------------------------------- /serf/test/main/net/leave/force_leave_leaving.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{leave::serf_force_leave_leaving, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_force_leave_leaving_v4() { 19 | let name = "serf_force_leave_leaving1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_force_leave_leaving2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | let name = "serf_force_leave_leaving3_v4"; 28 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 29 | opts3.add_bind_address(next_socket_addr_v4(0)); 30 | 31 | [< $rt:snake _run >](serf_force_leave_leaving::< 32 | NetTransport< 33 | SmolStr, 34 | SocketAddrResolver<[< $rt:camel Runtime >]>, 35 | Tcp<[< $rt:camel Runtime >]>, 36 | 37 | [< $rt:camel Runtime >], 38 | >, 39 | >(opts, opts2, opts3)); 40 | } 41 | 42 | #[test] 43 | fn test_serf_force_leave_leaving_v6() { 44 | let name = "serf_force_leave_leaving1_v6"; 45 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 46 | opts.add_bind_address(next_socket_addr_v6()); 47 | 48 | let name = "serf_force_leave_leaving2_v6"; 49 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 50 | opts2.add_bind_address(next_socket_addr_v6()); 51 | 52 | let name = "serf_force_leave_leaving3_v6"; 53 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 54 | opts3.add_bind_address(next_socket_addr_v6()); 55 | 56 | [< $rt:snake _run >](serf_force_leave_leaving::< 57 | NetTransport< 58 | SmolStr, 59 | SocketAddrResolver<[< $rt:camel Runtime >]>, 60 | Tcp<[< $rt:camel Runtime >]>, 61 | 62 | [< $rt:camel Runtime >], 63 | >, 64 | >(opts, opts2, opts3)); 65 | } 66 | } 67 | } 68 | }; 69 | } 70 | 71 | #[cfg(feature = "tokio")] 72 | test_mod!(tokio); 73 | 74 | #[cfg(feature = "async-std")] 75 | test_mod!(async_std); 76 | 77 | #[cfg(feature = "smol")] 78 | test_mod!(smol); 79 | -------------------------------------------------------------------------------- /serf/test/main/net/leave/force_leave_left.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{leave::serf_force_leave_left, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_force_leave_left_v4() { 19 | let name = "serf_force_leave_left1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_force_leave_left2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | let name = "serf_force_leave_left3_v4"; 28 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 29 | opts3.add_bind_address(next_socket_addr_v4(0)); 30 | 31 | [< $rt:snake _run >](serf_force_leave_left::< 32 | NetTransport< 33 | SmolStr, 34 | SocketAddrResolver<[< $rt:camel Runtime >]>, 35 | Tcp<[< $rt:camel Runtime >]>, 36 | 37 | [< $rt:camel Runtime >], 38 | >, 39 | >(opts, opts2, opts3)); 40 | } 41 | 42 | #[test] 43 | fn test_serf_force_leave_left_v6() { 44 | let name = "serf_force_leave_left1_v6"; 45 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 46 | opts.add_bind_address(next_socket_addr_v6()); 47 | 48 | let name = "serf_force_leave_left2_v6"; 49 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 50 | opts2.add_bind_address(next_socket_addr_v6()); 51 | 52 | let name = "serf_force_leave_left3_v6"; 53 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 54 | opts3.add_bind_address(next_socket_addr_v6()); 55 | 56 | [< $rt:snake _run >](serf_force_leave_left::< 57 | NetTransport< 58 | SmolStr, 59 | SocketAddrResolver<[< $rt:camel Runtime >]>, 60 | Tcp<[< $rt:camel Runtime >]>, 61 | 62 | [< $rt:camel Runtime >], 63 | >, 64 | >(opts, opts2, opts3)); 65 | } 66 | } 67 | } 68 | }; 69 | } 70 | 71 | #[cfg(feature = "tokio")] 72 | test_mod!(tokio); 73 | 74 | #[cfg(feature = "async-std")] 75 | test_mod!(async_std); 76 | 77 | #[cfg(feature = "smol")] 78 | test_mod!(smol); 79 | -------------------------------------------------------------------------------- /serf/test/main/net/leave/intent_buffer_early.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{leave::leave_intent_buffer_early, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_leave_intent_buffer_early_v4() { 19 | let name = "leave_intent_buffer_early_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](leave_intent_buffer_early::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts)); 32 | } 33 | 34 | #[test] 35 | fn test_leave_intent_buffer_early_v6() { 36 | let name = "leave_intent_buffer_early_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](leave_intent_buffer_early::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts)); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/leave/intent_newer.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{leave::leave_intent_newer, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_leave_intent_newer_v4() { 19 | let name = "leave_intent_newer_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](leave_intent_newer::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, next_socket_addr_v4(0))); 32 | } 33 | 34 | #[test] 35 | fn test_leave_intent_newer_v6() { 36 | let name = "leave_intent_newer_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](leave_intent_newer::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts, next_socket_addr_v6())); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/leave/intent_old_message.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{leave::leave_intent_old_message, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_leave_intent_old_message_v4() { 19 | let name = "leave_intent_old_message_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](leave_intent_old_message::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, next_socket_addr_v4(0))); 32 | } 33 | 34 | #[test] 35 | fn test_leave_intent_old_message_v6() { 36 | let name = "leave_intent_old_message_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](leave_intent_old_message::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts, next_socket_addr_v6())); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/leave/rejoin_different_role.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{leave::serf_leave_rejoin_different_role, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_leave_rejoin_different_role_v4() { 19 | let name = "serf_leave_rejoin_different_role1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_leave_rejoin_different_role2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_leave_rejoin_different_role::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_serf_leave_rejoin_different_role_v6() { 40 | let name = "serf_leave_rejoin_different_role1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_leave_rejoin_different_role2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_leave_rejoin_different_role::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/leave/snapshot_recovery.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{leave::serf_leave_snapshot_recovery, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_leave_snapshot_recovery_v4() { 19 | let name = "serf_leave_snapshot_recovery1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_leave_snapshot_recovery2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_leave_snapshot_recovery::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | _ 36 | >(opts, opts2, |id, addr| async move { 37 | let mut opts2 = NetTransportOptions::new(id); 38 | opts2.add_bind_address(addr); 39 | opts2 40 | })); 41 | } 42 | 43 | #[test] 44 | fn test_serf_leave_snapshot_recovery_v6() { 45 | let name = "serf_leave_snapshot_recovery1_v6"; 46 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 47 | opts.add_bind_address(next_socket_addr_v6()); 48 | 49 | let name = "serf_leave_snapshot_recovery2_v6"; 50 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 51 | opts2.add_bind_address(next_socket_addr_v6()); 52 | 53 | [< $rt:snake _run >](serf_leave_snapshot_recovery::< 54 | NetTransport< 55 | SmolStr, 56 | SocketAddrResolver<[< $rt:camel Runtime >]>, 57 | Tcp<[< $rt:camel Runtime >]>, 58 | 59 | [< $rt:camel Runtime >], 60 | >, 61 | _ 62 | >(opts, opts2, |id, addr| async move { 63 | let mut opts2 = NetTransportOptions::new(id); 64 | opts2.add_bind_address(addr); 65 | opts2 66 | })); 67 | } 68 | } 69 | } 70 | }; 71 | } 72 | 73 | #[cfg(feature = "tokio")] 74 | test_mod!(tokio); 75 | 76 | #[cfg(feature = "async-std")] 77 | test_mod!(async_std); 78 | 79 | #[cfg(feature = "smol")] 80 | test_mod!(smol); 81 | -------------------------------------------------------------------------------- /serf/test/main/net/local_member.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{serf_local_member, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_local_member_v4() { 19 | let name = "serf_local_member_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](serf_local_member::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts)); 32 | } 33 | 34 | #[test] 35 | fn test_serf_local_member_v6() { 36 | let name = "serf_local_member_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](serf_local_member::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts)); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/name_resolution.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{serf_name_resolution, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_name_resolution_v4() { 19 | let name = "serf_name_resolution1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_name_resolution2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | let name = "serf_name_resolution3_v4"; 28 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 29 | opts3.add_bind_address(next_socket_addr_v4(0)); 30 | 31 | [< $rt:snake _run >](serf_name_resolution::< 32 | NetTransport< 33 | SmolStr, 34 | SocketAddrResolver<[< $rt:camel Runtime >]>, 35 | Tcp<[< $rt:camel Runtime >]>, 36 | 37 | [< $rt:camel Runtime >], 38 | >, 39 | >(opts, opts2, opts3, |opts, id| opts.with_id(id))); 40 | } 41 | 42 | #[test] 43 | fn test_serf_name_resolution_v6() { 44 | let name = "serf_name_resolution1_v6"; 45 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 46 | opts.add_bind_address(next_socket_addr_v6()); 47 | 48 | let name = "serf_name_resolution2_v6"; 49 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 50 | opts2.add_bind_address(next_socket_addr_v6()); 51 | 52 | let name = "serf_name_resolution3_v6"; 53 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 54 | opts3.add_bind_address(next_socket_addr_v6()); 55 | 56 | [< $rt:snake _run >](serf_name_resolution::< 57 | NetTransport< 58 | SmolStr, 59 | SocketAddrResolver<[< $rt:camel Runtime >]>, 60 | Tcp<[< $rt:camel Runtime >]>, 61 | 62 | [< $rt:camel Runtime >], 63 | >, 64 | >(opts, opts2, opts3, |opts, id| opts.with_id(id))); 65 | } 66 | } 67 | } 68 | }; 69 | } 70 | 71 | #[cfg(feature = "tokio")] 72 | test_mod!(tokio); 73 | 74 | #[cfg(feature = "async-std")] 75 | test_mod!(async_std); 76 | 77 | #[cfg(feature = "smol")] 78 | test_mod!(smol); 79 | -------------------------------------------------------------------------------- /serf/test/main/net/num_nodes.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{serf_num_nodes, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_num_nodes_v4() { 19 | let name = "serf_num_nodes1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_num_nodes2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_num_nodes::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_serf_num_nodes_v6() { 40 | let name = "serf_num_nodes1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_num_nodes2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_num_nodes::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/reap.rs: -------------------------------------------------------------------------------- 1 | #[allow(clippy::module_inception)] 2 | #[path = "./reap/reap.rs"] 3 | mod reap; 4 | 5 | #[path = "./reap/handler.rs"] 6 | mod handler; 7 | 8 | #[path = "./reap/handler_shutdown.rs"] 9 | mod handler_shutdown; 10 | -------------------------------------------------------------------------------- /serf/test/main/net/reap/handler.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{reap::serf_reap_handler, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_reap_handler_v4() { 19 | let name = "serf_reap_handler_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](serf_reap_handler::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, next_socket_addr_v4(0))); 32 | } 33 | 34 | #[test] 35 | fn test_serf_reap_handler_v6() { 36 | let name = "serf_reap_handler_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](serf_reap_handler::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts, next_socket_addr_v6())); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/reap/handler_shutdown.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{reap::serf_reap_handler_shutdown, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_reap_handler_shutdown_v4() { 19 | let name = "serf_reap_handler_shutdown_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](serf_reap_handler_shutdown::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts)); 32 | } 33 | 34 | #[test] 35 | fn test_serf_reap_handler_shutdown_v6() { 36 | let name = "serf_reap_handler_shutdown_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](serf_reap_handler_shutdown::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts)); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/reap/reap.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{reap::serf_reap, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_reap_v4() { 19 | let name = "serf_reap_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](serf_reap::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, next_socket_addr_v4(0))); 32 | } 33 | 34 | #[test] 35 | fn test_serf_reap_v6() { 36 | let name = "serf_reap_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](serf_reap::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts, next_socket_addr_v6())); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/reconnect.rs: -------------------------------------------------------------------------------- 1 | #[allow(clippy::module_inception)] 2 | #[path = "./reconnect/reconnect.rs"] 3 | mod reconnect; 4 | 5 | #[path = "./reconnect/same_ip.rs"] 6 | mod same_ip; 7 | 8 | #[path = "./reconnect/timeout.rs"] 9 | mod timeout; 10 | -------------------------------------------------------------------------------- /serf/test/main/net/reconnect/reconnect.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{reconnect::serf_reconnect, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_reconnect_v4() { 19 | let name = "serf_reconnect1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_reconnect2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_reconnect::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | _, 36 | >(opts, opts2, |id, addr| async move { 37 | let mut opts2 = NetTransportOptions::new(id); 38 | opts2.add_bind_address(addr); 39 | opts2 40 | })); 41 | } 42 | 43 | #[test] 44 | fn test_serf_reconnect_v6() { 45 | let name = "serf_reconnect1_v6"; 46 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 47 | opts.add_bind_address(next_socket_addr_v6()); 48 | 49 | let name = "serf_reconnect2_v6"; 50 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 51 | opts2.add_bind_address(next_socket_addr_v6()); 52 | 53 | [< $rt:snake _run >](serf_reconnect::< 54 | NetTransport< 55 | SmolStr, 56 | SocketAddrResolver<[< $rt:camel Runtime >]>, 57 | Tcp<[< $rt:camel Runtime >]>, 58 | 59 | [< $rt:camel Runtime >], 60 | >, 61 | _, 62 | >(opts, opts2, |id, addr| async move { 63 | let mut opts2 = NetTransportOptions::new(id); 64 | opts2.add_bind_address(addr); 65 | opts2 66 | })); 67 | } 68 | } 69 | } 70 | }; 71 | } 72 | 73 | #[cfg(feature = "tokio")] 74 | test_mod!(tokio); 75 | 76 | #[cfg(feature = "async-std")] 77 | test_mod!(async_std); 78 | 79 | #[cfg(feature = "smol")] 80 | test_mod!(smol); 81 | -------------------------------------------------------------------------------- /serf/test/main/net/reconnect/same_ip.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{reconnect::serf_reconnect_same_ip, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_reconnect_same_ip_v4() { 19 | let name = "serf_reconnect_same_ip1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_reconnect_same_ip2_v4"; 24 | 25 | [< $rt:snake _run >](serf_reconnect_same_ip::< 26 | NetTransport< 27 | SmolStr, 28 | SocketAddrResolver<[< $rt:camel Runtime >]>, 29 | Tcp<[< $rt:camel Runtime >]>, 30 | 31 | [< $rt:camel Runtime >], 32 | >, 33 | _, 34 | _ 35 | >(opts, SmolStr::new(name), |id, addr| async move { 36 | let mut opts2 = NetTransportOptions::new(id); 37 | opts2.add_bind_address(addr); 38 | opts2 39 | })); 40 | } 41 | 42 | #[test] 43 | fn test_serf_reconnect_same_ip_v6() { 44 | let name = "serf_reconnect_same_ip1_v6"; 45 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 46 | opts.add_bind_address(next_socket_addr_v6()); 47 | 48 | let name = "serf_reconnect_same_ip2_v6"; 49 | 50 | [< $rt:snake _run >](serf_reconnect_same_ip::< 51 | NetTransport< 52 | SmolStr, 53 | SocketAddrResolver<[< $rt:camel Runtime >]>, 54 | Tcp<[< $rt:camel Runtime >]>, 55 | 56 | [< $rt:camel Runtime >], 57 | >, 58 | _, 59 | _, 60 | >(opts, SmolStr::new(name), |id, addr| async move { 61 | let mut opts2 = NetTransportOptions::new(id); 62 | opts2.add_bind_address(addr); 63 | opts2 64 | })); 65 | } 66 | } 67 | } 68 | }; 69 | } 70 | 71 | #[cfg(feature = "tokio")] 72 | test_mod!(tokio); 73 | 74 | #[cfg(feature = "async-std")] 75 | test_mod!(async_std); 76 | 77 | #[cfg(feature = "smol")] 78 | test_mod!(smol); 79 | -------------------------------------------------------------------------------- /serf/test/main/net/reconnect/timeout.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{reconnect::serf_per_node_reconnect_timeout, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_per_node_reconnect_timeout_v4() { 19 | let name = "serf_per_node_reconnect_timeout1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_per_node_reconnect_timeout2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_per_node_reconnect_timeout::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_serf_per_node_reconnect_timeout_v6() { 40 | let name = "serf_per_node_reconnect_timeout1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_per_node_reconnect_timeout2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_per_node_reconnect_timeout::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/remove.rs: -------------------------------------------------------------------------------- 1 | #[path = "./remove/failed_node.rs"] 2 | mod failed_node; 3 | 4 | #[path = "./remove/failed_node_prune.rs"] 5 | mod failed_node_prune; 6 | 7 | #[path = "./remove/failed_node_ourself.rs"] 8 | mod failed_node_ourself; 9 | -------------------------------------------------------------------------------- /serf/test/main/net/remove/failed_node.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{remove::serf_remove_failed_node, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_remove_failed_node_v4() { 19 | let name = "serf_remove_failed_node1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_remove_failed_node2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | let name = "serf_remove_failed_node3_v4"; 28 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 29 | opts3.add_bind_address(next_socket_addr_v4(0)); 30 | 31 | [< $rt:snake _run >](serf_remove_failed_node::< 32 | NetTransport< 33 | SmolStr, 34 | SocketAddrResolver<[< $rt:camel Runtime >]>, 35 | Tcp<[< $rt:camel Runtime >]>, 36 | 37 | [< $rt:camel Runtime >], 38 | >, 39 | >(opts, opts2, opts3)); 40 | } 41 | 42 | #[test] 43 | fn test_serf_remove_failed_node_v6() { 44 | let name = "serf_remove_failed_node1_v6"; 45 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 46 | opts.add_bind_address(next_socket_addr_v6()); 47 | 48 | let name = "serf_remove_failed_node2_v6"; 49 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 50 | opts2.add_bind_address(next_socket_addr_v6()); 51 | 52 | let name = "serf_remove_failed_node3_v6"; 53 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 54 | opts3.add_bind_address(next_socket_addr_v6()); 55 | 56 | [< $rt:snake _run >](serf_remove_failed_node::< 57 | NetTransport< 58 | SmolStr, 59 | SocketAddrResolver<[< $rt:camel Runtime >]>, 60 | Tcp<[< $rt:camel Runtime >]>, 61 | 62 | [< $rt:camel Runtime >], 63 | >, 64 | >(opts, opts2, opts3)); 65 | } 66 | } 67 | } 68 | }; 69 | } 70 | 71 | #[cfg(feature = "tokio")] 72 | test_mod!(tokio); 73 | 74 | #[cfg(feature = "async-std")] 75 | test_mod!(async_std); 76 | 77 | #[cfg(feature = "smol")] 78 | test_mod!(smol); 79 | -------------------------------------------------------------------------------- /serf/test/main/net/remove/failed_node_ourself.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{remove::serf_remove_failed_node_ourself, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_remove_failed_node_ourself_v4() { 19 | let name = "serf_remove_failed_node_ourself_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](serf_remove_failed_node_ourself::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts)); 32 | } 33 | 34 | #[test] 35 | fn test_serf_remove_failed_node_ourself_v6() { 36 | let name = "serf_remove_failed_node_ourself_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](serf_remove_failed_node_ourself::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts)); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/remove/failed_node_prune.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{remove::serf_remove_failed_node_prune, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_remove_failed_node_prune_v4() { 19 | let name = "serf_remove_failed_node_prune1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_remove_failed_node_prune2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | let name = "serf_remove_failed_node_prune3_v4"; 28 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 29 | opts3.add_bind_address(next_socket_addr_v4(0)); 30 | 31 | [< $rt:snake _run >](serf_remove_failed_node_prune::< 32 | NetTransport< 33 | SmolStr, 34 | SocketAddrResolver<[< $rt:camel Runtime >]>, 35 | Tcp<[< $rt:camel Runtime >]>, 36 | 37 | [< $rt:camel Runtime >], 38 | >, 39 | >(opts, opts2, opts3)); 40 | } 41 | 42 | #[test] 43 | fn test_serf_remove_failed_node_prune_v6() { 44 | let name = "serf_remove_failed_node_prune1_v6"; 45 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 46 | opts.add_bind_address(next_socket_addr_v6()); 47 | 48 | let name = "serf_remove_failed_node_prune2_v6"; 49 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 50 | opts2.add_bind_address(next_socket_addr_v6()); 51 | 52 | let name = "serf_remove_failed_node_prune3_v6"; 53 | let mut opts3 = NetTransportOptions::new(SmolStr::new(name)); 54 | opts3.add_bind_address(next_socket_addr_v6()); 55 | 56 | [< $rt:snake _run >](serf_remove_failed_node_prune::< 57 | NetTransport< 58 | SmolStr, 59 | SocketAddrResolver<[< $rt:camel Runtime >]>, 60 | Tcp<[< $rt:camel Runtime >]>, 61 | 62 | [< $rt:camel Runtime >], 63 | >, 64 | >(opts, opts2, opts3)); 65 | } 66 | } 67 | } 68 | }; 69 | } 70 | 71 | #[cfg(feature = "tokio")] 72 | test_mod!(tokio); 73 | 74 | #[cfg(feature = "async-std")] 75 | test_mod!(async_std); 76 | 77 | #[cfg(feature = "smol")] 78 | test_mod!(smol); 79 | -------------------------------------------------------------------------------- /serf/test/main/net/role.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{serf_role, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_role_v4() { 19 | let name = "serf_role1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_role2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_role::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_serf_role_v6() { 40 | let name = "serf_role1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_role2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_role::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/set_tags.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{serf_set_tags, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_set_tags_v4() { 19 | let name = "serf_set_tags1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_set_tags2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_set_tags::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | >(opts, opts2)); 36 | } 37 | 38 | #[test] 39 | fn test_serf_set_tags_v6() { 40 | let name = "serf_set_tags1_v6"; 41 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 42 | opts.add_bind_address(next_socket_addr_v6()); 43 | 44 | let name = "serf_set_tags2_v6"; 45 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 46 | opts2.add_bind_address(next_socket_addr_v6()); 47 | 48 | [< $rt:snake _run >](serf_set_tags::< 49 | NetTransport< 50 | SmolStr, 51 | SocketAddrResolver<[< $rt:camel Runtime >]>, 52 | Tcp<[< $rt:camel Runtime >]>, 53 | 54 | [< $rt:camel Runtime >], 55 | >, 56 | >(opts, opts2)); 57 | } 58 | } 59 | } 60 | }; 61 | } 62 | 63 | #[cfg(feature = "tokio")] 64 | test_mod!(tokio); 65 | 66 | #[cfg(feature = "async-std")] 67 | test_mod!(async_std); 68 | 69 | #[cfg(feature = "smol")] 70 | test_mod!(smol); 71 | -------------------------------------------------------------------------------- /serf/test/main/net/snapshot.rs: -------------------------------------------------------------------------------- 1 | #[path = "./snapshot/snapshoter.rs"] 2 | mod snapshoter; 3 | 4 | #[path = "./snapshot/snapshoter_leave.rs"] 5 | mod snapshoter_leave; 6 | 7 | #[path = "./snapshot/snapshoter_leave_rejoin.rs"] 8 | mod snapshoter_leave_rejoin; 9 | 10 | #[path = "./snapshot/snapshoter_recovery.rs"] 11 | mod snapshoter_recovery; 12 | 13 | #[path = "./snapshot/snapshoter_force_compact.rs"] 14 | mod snapshoter_force_compact; 15 | -------------------------------------------------------------------------------- /serf/test/main/net/snapshot/snapshoter.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{snapshot::snapshoter, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_snapshoter_v4() { 19 | let name = "snapshoter_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](snapshoter::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, next_socket_addr_v4(0))); 32 | } 33 | 34 | #[test] 35 | fn test_snapshoter_v6() { 36 | let name = "snapshoter_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](snapshoter::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts, next_socket_addr_v6())); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/snapshot/snapshoter_force_compact.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{snapshot::snapshoter_force_compact, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_snapshoter_force_compact_v4() { 19 | let name = "snapshoter_force_compact_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](snapshoter_force_compact::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, next_socket_addr_v4(0))); 32 | } 33 | 34 | #[test] 35 | fn test_snapshoter_force_compact_v6() { 36 | let name = "snapshoter_force_compact_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](snapshoter_force_compact::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts, next_socket_addr_v6())); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/snapshot/snapshoter_leave.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{snapshot::snapshoter_leave, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_snapshoter_leave_v4() { 19 | let name = "snapshoter_leave_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](snapshoter_leave::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, next_socket_addr_v4(0))); 32 | } 33 | 34 | #[test] 35 | fn test_snapshoter_leave_v6() { 36 | let name = "snapshoter_leave_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](snapshoter_leave::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts, next_socket_addr_v6())); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/snapshot/snapshoter_leave_rejoin.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{snapshot::snapshoter_leave_rejoin, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_snapshoter_leave_rejoin_v4() { 19 | let name = "snapshoter_leave_rejoin_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](snapshoter_leave_rejoin::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts, next_socket_addr_v4(0))); 32 | } 33 | 34 | #[test] 35 | fn test_snapshoter_leave_rejoin_v6() { 36 | let name = "snapshoter_leave_rejoin_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](snapshoter_leave_rejoin::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts, next_socket_addr_v6())); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/snapshot/snapshoter_recovery.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{snapshot::serf_snapshot_recovery, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_snapshot_recovery_v4() { 19 | let name = "serf_snapshot_recovery1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_snapshot_recovery2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_snapshot_recovery::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | _ 36 | >(opts, opts2, |id, addr| async move { 37 | let mut opts2 = NetTransportOptions::new(id); 38 | opts2.add_bind_address(addr); 39 | opts2 40 | })); 41 | } 42 | 43 | #[test] 44 | fn test_serf_snapshot_recovery_v6() { 45 | let name = "serf_snapshot_recovery1_v6"; 46 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 47 | opts.add_bind_address(next_socket_addr_v6()); 48 | 49 | let name = "serf_snapshot_recovery2_v6"; 50 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 51 | opts2.add_bind_address(next_socket_addr_v6()); 52 | 53 | [< $rt:snake _run >](serf_snapshot_recovery::< 54 | NetTransport< 55 | SmolStr, 56 | SocketAddrResolver<[< $rt:camel Runtime >]>, 57 | Tcp<[< $rt:camel Runtime >]>, 58 | 59 | [< $rt:camel Runtime >], 60 | >, 61 | _, 62 | >(opts, opts2, |id, addr| async move { 63 | let mut opts2 = NetTransportOptions::new(id); 64 | opts2.add_bind_address(addr); 65 | opts2 66 | })); 67 | } 68 | } 69 | } 70 | }; 71 | } 72 | 73 | #[cfg(feature = "tokio")] 74 | test_mod!(tokio); 75 | 76 | #[cfg(feature = "async-std")] 77 | test_mod!(async_std); 78 | 79 | #[cfg(feature = "smol")] 80 | test_mod!(smol); 81 | -------------------------------------------------------------------------------- /serf/test/main/net/state.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{serf_state, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_state_v4() { 19 | let name = "serf_state_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](serf_state::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts)); 32 | } 33 | 34 | #[test] 35 | fn test_serf_state_v6() { 36 | let name = "serf_state_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](serf_state::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts)); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/stats.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{serf_stats, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_stats_v4() { 19 | let name = "serf_stats_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](serf_stats::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(opts)); 32 | } 33 | 34 | #[test] 35 | fn test_serf_stats_v6() { 36 | let name = "serf_stats_v6"; 37 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 38 | opts.add_bind_address(next_socket_addr_v6()); 39 | 40 | [< $rt:snake _run >](serf_stats::< 41 | NetTransport< 42 | SmolStr, 43 | SocketAddrResolver<[< $rt:camel Runtime >]>, 44 | Tcp<[< $rt:camel Runtime >]>, 45 | 46 | [< $rt:camel Runtime >], 47 | >, 48 | >(opts)); 49 | } 50 | } 51 | } 52 | }; 53 | } 54 | 55 | #[cfg(feature = "tokio")] 56 | test_mod!(tokio); 57 | 58 | #[cfg(feature = "async-std")] 59 | test_mod!(async_std); 60 | 61 | #[cfg(feature = "smol")] 62 | test_mod!(smol); 63 | -------------------------------------------------------------------------------- /serf/test/main/net/update.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::tests::{serf_update, next_socket_addr_v4, next_socket_addr_v6}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_update_v4() { 19 | let name = "serf_update1_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | let name = "serf_update2_v4"; 24 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 25 | opts2.add_bind_address(next_socket_addr_v4(0)); 26 | 27 | [< $rt:snake _run >](serf_update::< 28 | NetTransport< 29 | SmolStr, 30 | SocketAddrResolver<[< $rt:camel Runtime >]>, 31 | Tcp<[< $rt:camel Runtime >]>, 32 | 33 | [< $rt:camel Runtime >], 34 | >, 35 | _, 36 | >(opts, opts2, |id, addr| async move { 37 | let mut opts2 = NetTransportOptions::new(id); 38 | opts2.add_bind_address(addr); 39 | opts2 40 | })); 41 | } 42 | 43 | #[test] 44 | fn test_serf_update_v6() { 45 | let name = "serf_update1_v6"; 46 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 47 | opts.add_bind_address(next_socket_addr_v6()); 48 | 49 | let name = "serf_update2_v6"; 50 | let mut opts2 = NetTransportOptions::new(SmolStr::new(name)); 51 | opts2.add_bind_address(next_socket_addr_v6()); 52 | 53 | [< $rt:snake _run >](serf_update::< 54 | NetTransport< 55 | SmolStr, 56 | SocketAddrResolver<[< $rt:camel Runtime >]>, 57 | Tcp<[< $rt:camel Runtime >]>, 58 | 59 | [< $rt:camel Runtime >], 60 | >, 61 | _, 62 | >(opts, opts2, |id, addr| async move { 63 | let mut opts2 = NetTransportOptions::new(id); 64 | opts2.add_bind_address(addr); 65 | opts2 66 | })); 67 | } 68 | } 69 | } 70 | }; 71 | } 72 | 73 | #[cfg(feature = "tokio")] 74 | test_mod!(tokio); 75 | 76 | #[cfg(feature = "async-std")] 77 | test_mod!(async_std); 78 | 79 | #[cfg(feature = "smol")] 80 | test_mod!(smol); 81 | -------------------------------------------------------------------------------- /serf/test/main/net/write_keyring_file.rs: -------------------------------------------------------------------------------- 1 | macro_rules! test_mod { 2 | ($rt:ident) => { 3 | paste::paste! { 4 | mod [< $rt:snake >] { 5 | use crate::[< $rt:snake _run >]; 6 | use serf::{ 7 | net::{ 8 | resolver::socket_addr::SocketAddrResolver, stream_layer::tcp::Tcp, NetTransport, 9 | NetTransportOptions, 10 | }, 11 | [< $rt:snake >]::[< $rt:camel Runtime >], 12 | 13 | }; 14 | use serf_core::{tests::{serf_write_keyring_file, next_socket_addr_v4, next_socket_addr_v6}, MemberlistOptions, types::EncryptionAlgorithm}; 15 | use smol_str::SmolStr; 16 | 17 | #[test] 18 | fn test_serf_write_keyring_file_v4() { 19 | let name = "serf_write_keyring_file_v4"; 20 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 21 | opts.add_bind_address(next_socket_addr_v4(0)); 22 | 23 | [< $rt:snake _run >](serf_write_keyring_file::< 24 | NetTransport< 25 | SmolStr, 26 | SocketAddrResolver<[< $rt:camel Runtime >]>, 27 | Tcp<[< $rt:camel Runtime >]>, 28 | 29 | [< $rt:camel Runtime >], 30 | >, 31 | >(|kr| { 32 | (opts, MemberlistOptions::lan().with_primary_key(kr).with_gossip_verify_outgoing(true).with_encryption_algo(EncryptionAlgorithm::default())) 33 | })); 34 | } 35 | 36 | #[test] 37 | fn test_serf_write_keyring_file_v6() { 38 | let name = "serf_write_keyring_file_v6"; 39 | let mut opts = NetTransportOptions::new(SmolStr::new(name)); 40 | opts.add_bind_address(next_socket_addr_v6()); 41 | 42 | [< $rt:snake _run >](serf_write_keyring_file::< 43 | NetTransport< 44 | SmolStr, 45 | SocketAddrResolver<[< $rt:camel Runtime >]>, 46 | Tcp<[< $rt:camel Runtime >]>, 47 | 48 | [< $rt:camel Runtime >], 49 | >, 50 | >(|kr| { 51 | (opts, MemberlistOptions::lan().with_primary_key(kr).with_gossip_verify_outgoing(true).with_encryption_algo(EncryptionAlgorithm::default())) 52 | })); 53 | } 54 | } 55 | } 56 | }; 57 | } 58 | 59 | #[cfg(feature = "tokio")] 60 | test_mod!(tokio); 61 | 62 | #[cfg(feature = "async-std")] 63 | test_mod!(async_std); 64 | 65 | #[cfg(feature = "smol")] 66 | test_mod!(smol); 67 | --------------------------------------------------------------------------------