Add port-alloc utility.

Author: twittner

Cargo.lock

@@ -70,9 +70,9 @@ generic-array = { version = "0.14.7", features = ["serde", "zeroize"] }
 http = "1.3.1"
 jiff = { version = "0.2", default-features = false, features = ["serde", "std"] }
 minicbor = { version = "2.1.1", features = ["full"] }
+minicbor-io = { version = "0.23.0", features = ["async-io"] }
 nohash-hasher = "0.2"
 parking_lot = "0.12.3"
-portpicker = "0.1.1"
 prometheus = "0.14"
 prost = "0.14.1"
 quickcheck = "1.0.3"
@@ -94,7 +94,7 @@ thiserror = "2.0"
 tokio = { version = "1", default-features = false, features = ["full"] }
 tokio-stream = "0.1.17"
 tokio-tungstenite = { version = "0.27.0", features = ["rustls-tls-webpki-roots", "url"] }
-tokio-util = "0.7.15"
+tokio-util = { version = "0.7.15", features = ["compat"] }
 toml = "0.9"
 toml_edit = "0.22"
 tonic = "0.14.1"

Cargo.toml

@@ -24,10 +24,8 @@ turmoil = { workspace = true, optional = true }
 
 [dev-dependencies]
 criterion = { workspace = true }
-portpicker = { workspace = true }
 quickcheck = { workspace = true }
 
 [[bench]]
 name = "network_bytes"
 harness = false
-

cliquenet/Cargo.toml

@@ -3,7 +3,6 @@ use std::net::{Ipv4Addr, SocketAddr};
 use bytes::BytesMut;
 use cliquenet::{Network, NetworkMetrics, Overlay, overlay::Data};
 use multisig::{Keypair, PublicKey, x25519};
-use portpicker::pick_unused_port;
 use rand::{Rng, RngCore};
 use tokio::time::{Duration, timeout};
 
@@ -20,12 +19,12 @@ async fn multiple_frames() {
         (
             party_a_sign.public_key(),
             party_a_dh.public_key(),
-            (Ipv4Addr::LOCALHOST, pick_unused_port().unwrap()).into(),
+            (Ipv4Addr::LOCALHOST, 50000).into(),
         ),
         (
             party_b_sign.public_key(),
             party_b_dh.public_key(),
-            (Ipv4Addr::LOCALHOST, pick_unused_port().unwrap()).into(),
+            (Ipv4Addr::LOCALHOST, 51000).into(),
         ),
     ];
 

cliquenet/tests/frame-handling.rs

@@ -21,6 +21,10 @@ build_docker:
 build-contracts:
   forge build
 
+[private]
+build-tools:
+  cargo build --release --features bin --bin run --bin port-alloc
+
 ####################
 ###CHECK COMMANDS###
 ####################
@@ -127,21 +131,25 @@ verify_blocks *ARGS:
 ####################
 ####TEST COMMANDS###
 ####################
-test *ARGS:
-  cargo nextest run {{ARGS}}
+test *ARGS: build-tools
+  target/release/run --with target/release/port-alloc cargo nextest run {{ARGS}}
   @if [ "{{ARGS}}" == "" ]; then cargo test --doc; fi
 
 test-contracts: build-contracts
   forge test
 
-test_ci *ARGS:
-  env {{LOG_LEVELS}} NO_COLOR=1 cargo nextest run --workspace {{ARGS}}
+test_ci *ARGS: build-tools
+  env {{LOG_LEVELS}} NO_COLOR=1 target/release/run \
+    --with target/release/port-alloc \
+    -- cargo nextest run --workspace {{ARGS}}
   env {{LOG_LEVELS}} NO_COLOR=1 cargo test --doc {{ARGS}}
 
-test-individually:
+test-individually: build-tools
   @for pkg in $(cargo metadata --no-deps --format-version 1 | jq -r '.packages[].name'); do \
     echo "Testing $pkg"; \
-    cargo nextest run --no-tests=pass -p $pkg || exit 1; \
+    target/release/run \
+        --with target/release/port-alloc \
+        -- cargo nextest run --no-tests=pass -p $pkg || exit 1; \
   done
 
 test-contract-deploy *ARGS:

justfile

@@ -17,7 +17,6 @@ futures = { workspace = true }
 metrics = { path = "../metrics" }
 multisig = { path = "../multisig" }
 parking_lot = { workspace = true }
-portpicker = { workspace = true }
 rand = { workspace = true }
 sailfish = { path = "../sailfish", features = ["test"] }
 sailfish-types = { path = "../sailfish-types" }
@@ -33,11 +32,22 @@ url = { workspace = true }
 # optional:
 anyhow = { workspace = true, optional = true }
 clap = { workspace = true, optional = true }
+minicbor-io = { workspace = true, optional = true }
 
 [features]
-bin = ["dep:anyhow", "dep:clap"]
+bin = ["dep:anyhow", "dep:clap", "dep:minicbor-io"]
 
 [[bin]]
 name = "block-verifier"
 path = "src/binaries/block-verifier.rs"
 required-features = ["bin"]
+
+[[bin]]
+name = "run"
+path = "src/binaries/run.rs"
+required-features = ["bin"]
+
+[[bin]]
+name = "port-alloc"
+path = "src/binaries/port-alloc.rs"
+required-features = ["bin"]

tests/Cargo.toml

@@ -0,0 +1,57 @@
+use std::{
+    net::Ipv4Addr,
+    sync::{
+        Arc,
+        atomic::{AtomicU16, Ordering},
+    },
+};
+
+use anyhow::{Context, Result};
+use minicbor_io::{AsyncReader, AsyncWriter};
+use timeboost_utils::ports::{ALLOCATOR_PORT, Request, Response};
+use tokio::net::{TcpListener, TcpStream};
+use tokio_util::{
+    compat::{TokioAsyncReadCompatExt, TokioAsyncWriteCompatExt},
+    task::TaskTracker,
+};
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let tasks = TaskTracker::new();
+    let counter = Arc::new(AtomicU16::new(2048));
+
+    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, ALLOCATOR_PORT))
+        .await
+        .context("allocator port is in use")?;
+
+    loop {
+        let Ok((stream, _)) = listener.accept().await else {
+            continue;
+        };
+        tasks.spawn(alloc(stream, counter.clone()));
+    }
+}
+
+async fn alloc(mut stream: TcpStream, ctr: Arc<AtomicU16>) -> Result<()> {
+    let mut reader = AsyncReader::new((&mut stream).compat());
+    let Some(request) = reader.read().await? else {
+        return Ok(());
+    };
+    let mut writer = AsyncWriter::new(stream.compat_write());
+    match request {
+        Request::Alloc(n) => {
+            let mut ports = Vec::new();
+            for _ in 0..n {
+                loop {
+                    let port = ctr.fetch_add(1, Ordering::Relaxed);
+                    if TcpListener::bind((Ipv4Addr::LOCALHOST, port)).await.is_ok() {
+                        ports.push(port);
+                        break;
+                    }
+                }
+            }
+            writer.write(Response::Ports(ports)).await?;
+        }
+    }
+    Ok(())
+}