ts_transport_derp: rename to ts_derp

The transport implementation is secondary, now in an especially
meaningful sense given that transports communicate over PeerIds, while
derp uses NodePublicKeys. This rename aligns with separation of the
client into the core non-transport functionality, and a transport
wrapper that handles translating to and from PeerId (forthcoming in a
future commit).

Signed-off-by: Nathan Perry <nathan@tailscale.com>
Change-Id: If5dd9a39d4e1299fe999f8457e38e94a6a6a6964

Author: npry

ARCHITECTURE.md

@@ -19,7 +19,7 @@ point. More detailed usage instructions and technical details can be found in ea
 ```mermaid
 block-beta
 	columns 4
-	
+
     API["API/Language Bindings"]:4
     RT["Runtime"]:4
     CP["Control Plane"]:1
@@ -59,7 +59,7 @@ Implements the TCP, UDP, and raw socket abstractions for the overlay network (ta
 
 ### Control Plane
 
-Crates that communicate with Tailscale's control plane (or Headscale) and provide configuration for the data plane. The control plane handles authentication/authorization, node registration, policy updates, network map distribution, and much more for the nodes in a tailnet. 
+Crates that communicate with Tailscale's control plane (or Headscale) and provide configuration for the data plane. The control plane handles authentication/authorization, node registration, policy updates, network map distribution, and much more for the nodes in a tailnet.
 
 - [`ts_control`](ts_control/src/lib.rs): control plane client that handles registration, authorization/authentication, configuration, and streaming updates.
 - [`ts_control_noise`](ts_control_noise/src/lib.rs): abstraction that wraps control plane communications in a Noise IK tunnel, transparently handling cryptography for the client.
@@ -78,7 +78,7 @@ Types and (de)serialization code for control plane traffic "on the wire". `ts_co
 
 Crates that communicate with other Tailscale nodes on the tailnet. The data plane is responsible for actually exchanging packets between peers on the tailnet, including transport management (DERP, TUN, etc.), routing, packet filtering, and tunneling.
 
-- [`ts_dataplane`](ts_dataplane/src/lib.rs): wires all the individual data plane functions together, flowing inbound and outbound packets through the components in the correct order. The various data plane components are described below. 
+- [`ts_dataplane`](ts_dataplane/src/lib.rs): wires all the individual data plane functions together, flowing inbound and outbound packets through the components in the correct order. The various data plane components are described below.
 
 #### Packet Filtering
 
@@ -88,13 +88,13 @@ Crates that communicate with other Tailscale nodes on the tailnet. The data plan
 
 #### Routing
 
-  - [`ts_overlay_router`](ts_overlay_router/src/lib.rs): routing table implementation for overlay (tailnet) traffic; determines which peer to send outbound traffic to, and which overlay transport should receive inbound packets.  
+  - [`ts_overlay_router`](ts_overlay_router/src/lib.rs): routing table implementation for overlay (tailnet) traffic; determines which peer to send outbound traffic to, and which overlay transport should receive inbound packets.
   - [`ts_underlay_router`](ts_underlay_router/src/lib.rs): routing table implementation for underlay traffic; determines which underlay transport an outbound packet should be sent from, if any.
 
 #### Transports
 
-  - [`ts_transport`](ts_transport/src/lib.rs): traits that define transports and how they move traffic in and out of the overlay/underlay network. 
-  - [`ts_transport_derp`](ts_transport_derp/src/lib.rs): an underlay transport that exchanges packets between nodes via Designated Encrypted Relay for Packets (DERP) relay servers. 
+  - [`ts_transport`](ts_transport/src/lib.rs): traits that define transports and how they move traffic in and out of the overlay/underlay network.
+  - [`ts_derp`](ts_derp/src/lib.rs): an underlay transport that exchanges packets between nodes via Designated Encrypted Relay for Packets (DERP) relay servers.
   - [`ts_transport_tun`](ts_transport_tun/src/lib.rs): an overlay transport that exposes a TUN device on the local machine to send/receive packets on the overlay network (tailnet).
 
 #### Tunneling
@@ -106,9 +106,9 @@ Crates that communicate with other Tailscale nodes on the tailnet. The data plan
 Crates used throughout the codebase that provide generic algorithms, data structures, cross-cutting concerns, or development tooling.
 
 #### Algorithms and Data Structures
-  - [`ts_array256`](ts_array256/src/lib.rs): sparse array of 256 elements with configurable backing store, used with `ts_bart`. 
-  - [`ts_bart`](ts_bart/README.md): BAlanced Routing Table (BART) data structure for fast IP address/prefix search in routing tables and packet filtering.    
-  - [`ts_bitset`](ts_bitset/src/lib.rs): fixed-width bitset used to track presence of elements in `ts_array256`. 
+  - [`ts_array256`](ts_array256/src/lib.rs): sparse array of 256 elements with configurable backing store, used with `ts_bart`.
+  - [`ts_bart`](ts_bart/README.md): BAlanced Routing Table (BART) data structure for fast IP address/prefix search in routing tables and packet filtering.
+  - [`ts_bitset`](ts_bitset/src/lib.rs): fixed-width bitset used to track presence of elements in `ts_array256`.
   - [`ts_dynbitset`](ts_dynbitset/src/lib.rs): growable bitset built on top of `ts_bitset`, used with `ts_bart_packetfilter`.
   - [`ts_keys`](ts_keys/src/lib.rs): data structures representing all of Tailscale's x25519 keys (disco, node, machine, etc.).
   - [`ts_packet`](ts_packet/src/lib.rs): base types representing network packets.
@@ -121,12 +121,12 @@ Crates used throughout the codebase that provide generic algorithms, data struct
 
 #### Examples, Debugging, and Testing
   - [`ts_cli_util`](ts_cli_util/src/lib.rs): helpers for writing command line tools and initializing logging, used in examples.
-  - [`ts_test_util`](ts_test_util/src/lib.rs): common code used by our unit and integration tests, such as determining if the network is available. 
+  - [`ts_test_util`](ts_test_util/src/lib.rs): common code used by our unit and integration tests, such as determining if the network is available.
   - [`ts_hexdump`](ts_hexdump/src/lib.rs): traits and functions to generate canonical hexdumps of buffers for debug logging.
 
 #### Protocols
   - [`ts_disco_protocol`](ts_disco_protocol/src/lib.rs): incomplete implementation of Tailscale's discovery protocol (disco).
-  - [`ts_http_util`](ts_http_util/src/lib.rs): HTTP/1 and HTTP/2 client utilities used in `ts_control` and `ts_transport_derp`.
+  - [`ts_http_util`](ts_http_util/src/lib.rs): HTTP/1 and HTTP/2 client utilities used in `ts_control` and `ts_derp`.
   - [`ts_tls_util`](ts_tls_util/src/lib.rs): Transport Layer Sockets (TLS) utilities to manage certificates and establish secure connections over HTTP.
 
 #### Time

Cargo.lock

@@ -12,6 +12,7 @@ members = [
     "ts_control_noise",
     "ts_control_serde",
     "ts_dataplane",
+    "ts_derp",
     "ts_devtools",
     "ts_disco_protocol",
     "ts_dynbitset",
@@ -37,7 +38,6 @@ members = [
     "ts_time",
     "ts_tls_util",
     "ts_transport",
-    "ts_transport_derp",
     "ts_transport_tun",
     "ts_underlay_router",
     "ts_tunnel",
@@ -115,6 +115,7 @@ ts_control = { path = "ts_control", version = "0.2.0" }
 ts_control_noise = { path = "ts_control_noise", version = "0.2.0" }
 ts_control_serde = { path = "ts_control_serde", version = "0.2.0" }
 ts_dataplane = { path = "ts_dataplane", version = "0.2.0" }
+ts_derp = { path = "ts_derp", version = "0.2.0" }
 ts_disco_protocol = { path = "ts_disco_protocol", version = "0.2.0" }
 ts_dynbitset = { path = "ts_dynbitset", version = "0.2.0" }
 ts_hexdump = { path = "ts_hexdump", version = "0.2.0" }
@@ -136,7 +137,6 @@ ts_runtime = { path = "ts_runtime", version = "0.2.0" }
 ts_test_util = { path = "ts_test_util" }
 ts_time = { path = "ts_time", version = "0.2.0" }
 ts_transport = { path = "ts_transport", version = "0.2.0" }
-ts_transport_derp = { path = "ts_transport_derp", version = "0.2.0" }
 ts_transport_tun = { path = "ts_transport_tun", version = "0.2.0" }
 ts_underlay_router = { path = "ts_underlay_router", version = "0.2.0" }
 ts_tunnel = { path = "ts_tunnel", version = "0.2.0" }

Cargo.toml

@@ -16,7 +16,7 @@ rust-version.workspace = true
 tailscale.workspace = true
 ts_control.workspace = true
 ts_netcheck.workspace = true
-ts_transport_derp.workspace = true
+ts_derp.workspace = true
 
 # Unconditionally required dependencies.
 cfg-if.workspace = true

ts_cli_util/Cargo.toml

@@ -5,8 +5,8 @@ use std::sync::Arc;
 use futures_util::{Stream, StreamExt};
 use tracing::level_filters::LevelFilter;
 use tracing_subscriber::{Layer, layer::SubscriberExt, util::SubscriberInitExt};
+use ts_derp::{RegionId, ServerConnInfo};
 use ts_netcheck::RegionResult;
-use ts_transport_derp::{RegionId, ServerConnInfo};
 
 /// Result with a boxed [`core::error::Error`] trait object.
 pub type Result<T> = core::result::Result<T, Box<dyn core::error::Error + Send + Sync + 'static>>;

ts_cli_util/src/lib.rs

@@ -24,7 +24,7 @@ ts_packet.workspace = true
 ts_packetfilter.workspace = true
 ts_packetfilter_state.workspace = true
 ts_tls_util.workspace = true
-ts_transport_derp.workspace = true
+ts_derp.workspace = true
 
 # Unconditionally required dependencies.
 bytes.workspace = true
@@ -51,7 +51,7 @@ default = ["async_tokio"]
 async_tokio = ["dep:futures-util", "dep:tokio", "dep:tokio-stream"]
 
 # Allow derp connections to be made without verifying TLS certs. Only for use in tests.
-insecure-derp = ["ts_transport_derp/insecure-for-tests"]
+insecure-derp = ["ts_derp/insecure-for-tests"]
 # Allow control keys to be fetched over plain HTTP1 without TLS. Only for use in tests.
 insecure-keyfetch = []
 

ts_control/Cargo.toml

@@ -1,17 +1,17 @@
 use alloc::collections::BTreeMap;
 
-use ts_transport_derp::TlsValidationConfig;
+use ts_derp::TlsValidationConfig;
 
-/// The full derp state, a map of [`ts_transport_derp::RegionId`]s to [`Region`]s.
-pub type Map = BTreeMap<ts_transport_derp::RegionId, Region>;
+/// The full derp state, a map of [`ts_derp::RegionId`]s to [`Region`]s.
+pub type Map = BTreeMap<ts_derp::RegionId, Region>;
 
-/// Convert a derp map from the [`ts_control_serde`] representation to the [`ts_transport_derp`]
+/// Convert a derp map from the [`ts_control_serde`] representation to the [`ts_derp`]
 /// representation.
 pub fn convert_derp_map(
     derp_map: &ts_control_serde::DerpMap<'_>,
-) -> impl Iterator<Item = (ts_transport_derp::RegionId, Region)> {
+) -> impl Iterator<Item = (ts_derp::RegionId, Region)> {
     derp_map.regions.iter().map(|(id, region)| {
-        let id = ts_transport_derp::RegionId((*id).into());
+        let id = ts_derp::RegionId((*id).into());
         let region: Region = region.into();
 
         (id, region)
@@ -22,10 +22,10 @@ pub fn convert_derp_map(
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Region {
     /// The info for this region.
-    pub info: ts_transport_derp::RegionInfo,
+    pub info: ts_derp::RegionInfo,
 
     /// Servers in this region.
-    pub servers: Vec<ts_transport_derp::ServerConnInfo>,
+    pub servers: Vec<ts_derp::ServerConnInfo>,
 }
 
 impl From<&ts_control_serde::DerpRegion<'_>> for Region {
@@ -37,15 +37,15 @@ impl From<&ts_control_serde::DerpRegion<'_>> for Region {
     }
 }
 
-fn region_info(region: &ts_control_serde::DerpRegion) -> ts_transport_derp::RegionInfo {
-    ts_transport_derp::RegionInfo {
+fn region_info(region: &ts_control_serde::DerpRegion) -> ts_derp::RegionInfo {
+    ts_derp::RegionInfo {
         name: region.name.to_string(),
         code: region.code.to_string(),
         no_measure_no_home: region.no_measure_no_home,
     }
 }
 
-fn server(server: &ts_control_serde::DerpServer) -> ts_transport_derp::ServerConnInfo {
+fn server(server: &ts_control_serde::DerpServer) -> ts_derp::ServerConnInfo {
     const DEFAULT_TLS_PORT: u16 = 443;
 
     let https_port = match server.derp_port {
@@ -62,7 +62,7 @@ fn server(server: &ts_control_serde::DerpServer) -> ts_transport_derp::ServerCon
         tls_config = TlsValidationConfig::InsecureForTests;
     };
 
-    ts_transport_derp::ServerConnInfo {
+    ts_derp::ServerConnInfo {
         hostname: server.hostname.to_string(),
         https_port,
         stun_port: server.stun_port.into(),
@@ -77,13 +77,13 @@ fn server(server: &ts_control_serde::DerpServer) -> ts_transport_derp::ServerCon
     }
 }
 
-fn convert_ip_usage<T>(ip: ts_control_serde::DerpIpUsage<T>) -> ts_transport_derp::IpUsage<T>
+fn convert_ip_usage<T>(ip: ts_control_serde::DerpIpUsage<T>) -> ts_derp::IpUsage<T>
 where
     T: Copy,
 {
     match ip {
-        ts_control_serde::DerpIpUsage::Disable => ts_transport_derp::IpUsage::Disable,
-        ts_control_serde::DerpIpUsage::UseDns => ts_transport_derp::IpUsage::UseDns,
-        ts_control_serde::DerpIpUsage::FixedAddr(ip) => ts_transport_derp::IpUsage::FixedAddr(ip),
+        ts_control_serde::DerpIpUsage::Disable => ts_derp::IpUsage::Disable,
+        ts_control_serde::DerpIpUsage::UseDns => ts_derp::IpUsage::UseDns,
+        ts_control_serde::DerpIpUsage::FixedAddr(ip) => ts_derp::IpUsage::FixedAddr(ip),
     }
 }

ts_control/src/derp.rs

@@ -67,7 +67,7 @@ impl<'a> MapRequestBuilder<'a> {
 
     /// Set the [`NetInfo::preferred_derp`] field (inside [`MapRequest::host_info`] ->
     /// [`HostInfo::net_info`]).
-    pub fn preferred_derp(mut self, value: ts_transport_derp::RegionId) -> Self {
+    pub fn preferred_derp(mut self, value: ts_derp::RegionId) -> Self {
         self.net_info_mut().preferred_derp = Some(value.0.into());
         self
     }

ts_control/src/map_request_builder.rs

@@ -46,7 +46,7 @@ pub struct Node {
     pub underlay_addresses: Vec<SocketAddr>,
 
     /// The DERP region for this node, if known.
-    pub derp_region: Option<ts_transport_derp::RegionId>,
+    pub derp_region: Option<ts_derp::RegionId>,
 }
 
 impl Node {
@@ -166,7 +166,7 @@ impl From<&ts_control_serde::Node<'_>> for Node {
                 .home_derp
                 .or(value.legacy_derp_string)
                 .or_else(|| value.host_info.net_info.as_ref()?.preferred_derp)
-                .map(|x| ts_transport_derp::RegionId(x.into())),
+                .map(|x| ts_derp::RegionId(x.into())),
         }
     }
 }