Peer

pub trait Peer: Display + Clone {
    /// The remote address to connect to
    fn address(&self) -> &SocketAddr;
    /// If TLS should be used;
    fn tls(&self) -> bool;
    /// The SNI to send, if TLS is used
    fn sni(&self) -> &str;
    /// To decide whether a [`Peer`] can use the connection established by another [`Peer`].
    ///
    /// The connections to two peers are considered reusable to each other if their reuse hashes are
    /// the same
    fn reuse_hash(&self) -> u64;
    /// Get the proxy setting to connect to the remote server
    fn get_proxy(&self) -> Option<&Proxy> {
        None
    }
    /// Get the additional options to connect to the peer.
    ///
    /// See [`PeerOptions`] for more details
    fn get_peer_options(&self) -> Option<&PeerOptions> {
        None
    }
    // ...

pub struct HttpPeer {
    pub _address: SocketAddr,
    pub scheme: Scheme,
    pub sni: String,
    pub proxy: Option<Proxy>,
    pub client_cert_key: Option<Arc<CertKey>>,
    /// a custom field to isolate connection reuse. Requests with different group keys
    /// cannot share connections with each other.
    pub group_key: u64,
    pub options: PeerOptions,
}

impl Hash for HttpPeer {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self._address.hash(state);
        self.scheme.hash(state);
        self.proxy.hash(state);
        self.sni.hash(state);
        // client cert serial
        self.client_cert_key.hash(state);
        // origin server cert verification
        self.verify_cert().hash(state);
        self.verify_hostname().hash(state);
        self.alternative_cn().hash(state);
        #[cfg(feature = "s2n")]
        self.get_psk().hash(state);
        self.group_key.hash(state);
        // max h2 stream settings
        self.options.max_h2_streams.hash(state);
        // h2_stream_window_size and h2_connection_window_size are intentionally excluded
        // from the reuse hash for now. These are per-connection settings applied at handshake
        // time and may be revisited alongside other h2 settings that could be dynamically
        // adjusted over the lifetime of a connection.
        self.options.curves.hash(state);
        self.options.second_keyshare.hash(state);
    }
}

use std::time::Duration;
use pingora_core::upstreams::peer::{HttpPeer, Peer, ALPN};

fn base() -> HttpPeer {
  HttpPeer::new("127.0.0.1:18481", true, "a.example".to_string())
}

fn main() {
  let h0 = base().reuse_hash();
  let cases: Vec<(&str, Box<dyn Fn(&mut HttpPeer)>)> = vec![
    ("sni = b.example", Box::new(|p| p.sni = "b.example".into())),
    ("group_key = 1", Box::new(|p| p.group_key = 1)),
    ("verify_cert = false", Box::new(|p| p.options.verify_cert = false)),
    ("max_h2_streams = 100", Box::new(|p| p.options.max_h2_streams = 100)),
    ("curves = X25519", Box::new(|p| p.options.curves = Some("X25519".into()))),
    ("alpn = H2H1", Box::new(|p| p.options.alpn = ALPN::H2H1)),
    ("idle_timeout = 5s", Box::new(|p| p.options.idle_timeout = Some(Duration::from_secs(5)))),
    ("read_timeout = 5s", Box::new(|p| p.options.read_timeout = Some(Duration::from_secs(5)))),
    ("ca = self-signed cert", Box::new(|p| {
      let cert = rcgen::generate_simple_self_signed(vec!["ca.example".to_string()]).unwrap();
      let x = pingora_core::tls::x509::X509::from_pem(cert.cert.pem().as_bytes()).unwrap();
      p.options.ca = Some(std::sync::Arc::new(vec![x].into_boxed_slice()));
    })),
    // ... scheme、alternative_cn、second_keyshare、connection_timeout、
    //     h2_stream_window_size、tcp_fast_open 同样各一行
  ];
  println!("base: {h0:016x}");
  for (name, f) in cases {
    let mut p = base();
    f(&mut p);
    let h = p.reuse_hash();
    println!("{:<28} {}", name, if h == h0 { "same" } else { "DIFFERENT" });
  }
}

base: a486e725dfdf7749
sni = b.example              DIFFERENT
scheme = HTTP (tls false)    DIFFERENT
group_key = 1                DIFFERENT
verify_cert = false          DIFFERENT
alternative_cn               DIFFERENT
max_h2_streams = 100         DIFFERENT
curves = X25519              DIFFERENT
second_keyshare = false      DIFFERENT
alpn = H2H1                  same
idle_timeout = 5s            same
read_timeout = 5s            same
connection_timeout = 1s      same
h2_stream_window_size        same
tcp_fast_open = true         same
ca = self-signed cert        same
same process, twice: same