SYMBOL INDEX (4519 symbols across 200 files)

FILE: pingora-boringssl/src/boring_tokio.rs
  type StreamWrapper (line 27) | struct StreamWrapper<S> {
  function fmt (line 36) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
  function parts (line 46) | unsafe fn parts(&mut self) -> (Pin<&mut S>, &mut Context<'_>) {
  method read (line 58) | fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
  method write (line 72) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  method flush (line 80) | fn flush(&mut self) -> io::Result<()> {
  function cvt (line 89) | fn cvt<T>(r: io::Result<T>) -> Poll<io::Result<T>> {
  function cvt_ossl (line 97) | fn cvt_ossl<T>(r: Result<T, ssl::Error>) -> Poll<Result<T, ssl::Error>> {
  type SslStream (line 109) | pub struct SslStream<S>(SslStreamCore<StreamWrapper<S>>);
  function new (line 113) | pub fn new(ssl: Ssl, stream: S) -> Result<Self, ErrorStack> {
  function poll_connect (line 118) | pub fn poll_connect(
  function connect (line 126) | pub async fn connect(mut self: Pin<&mut Self>) -> Result<(), ssl::Error> {
  function poll_accept (line 131) | pub fn poll_accept(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<R...
  function accept (line 136) | pub async fn accept(mut self: Pin<&mut Self>) -> Result<(), ssl::Error> {
  function poll_do_handshake (line 141) | pub fn poll_do_handshake(
  function do_handshake (line 149) | pub async fn do_handshake(mut self: Pin<&mut Self>) -> Result<(), ssl::E...
  function ssl (line 158) | pub fn ssl(&self) -> &SslRef {
  function get_ref (line 163) | pub fn get_ref(&self) -> &S {
  function get_mut (line 168) | pub fn get_mut(&mut self) -> &mut S {
  function get_pin_mut (line 173) | pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut S> {
  function with_context (line 177) | fn with_context<F, R>(self: Pin<&mut Self>, ctx: &mut Context<'_>, f: F)...
  method poll_read (line 194) | fn poll_read(
  method poll_read (line 220) | fn poll_read(
  method poll_write (line 250) | fn poll_write(self: Pin<&mut Self>, ctx: &mut Context, buf: &[u8]) -> Po...
  method poll_flush (line 254) | fn poll_flush(self: Pin<&mut Self>, ctx: &mut Context) -> Poll<io::Resul...
  method poll_shutdown (line 258) | fn poll_shutdown(mut self: Pin<&mut Self>, ctx: &mut Context) -> Poll<io...
  function test_google (line 275) | async fn test_google() {

FILE: pingora-boringssl/src/ext.rs
  function cvt (line 27) | fn cvt(r: c_int) -> Result<c_int, ErrorStack> {
  function add_host (line 38) | pub fn add_host(verify_param: &mut X509VerifyParamRef, host: &str) -> Re...
  function ssl_set_verify_cert_store (line 55) | pub fn ssl_set_verify_cert_store(
  function ssl_use_certificate (line 71) | pub fn ssl_use_certificate(ssl: &mut SslRef, cert: &X509Ref) -> Result<(...
  function ssl_use_private_key (line 81) | pub fn ssl_use_private_key<T>(ssl: &mut SslRef, key: &PKeyRef<T>) -> Res...
  function ssl_add_chain_cert (line 94) | pub fn ssl_add_chain_cert(ssl: &mut SslRef, cert: &X509Ref) -> Result<()...
  function ssl_set_renegotiate_mode_freely (line 105) | pub fn ssl_set_renegotiate_mode_freely(ssl: &mut SslRef) {
  function ssl_set_groups_list (line 117) | pub fn ssl_set_groups_list(ssl: &mut SslRef, groups: &str) -> Result<(),...
  function ssl_use_second_key_share (line 134) | pub fn ssl_use_second_key_share(ssl: &mut SslRef, enabled: bool) {
  function ssl_use_second_key_share (line 138) | pub fn ssl_use_second_key_share(_ssl: &mut SslRef, _enabled: bool) {}
  function clear_error_stack (line 145) | pub fn clear_error_stack() {
  function ssl_from_acceptor (line 152) | pub fn ssl_from_acceptor(acceptor: &SslAcceptor) -> Result<Ssl, ErrorSta...
  function suspend_when_need_ssl_cert (line 161) | pub fn suspend_when_need_ssl_cert(ssl: &mut SslRef) {
  function unblock_ssl_cert (line 170) | pub fn unblock_ssl_cert(ssl: &mut SslRef) {
  function raw_cert_block (line 177) | extern "C" fn raw_cert_block(_ssl: *mut boring_sys::SSL, _arg: *mut c_vo...
  function is_suspended_for_cert (line 182) | pub fn is_suspended_for_cert(error: &boring::ssl::Error) -> bool {
  function ssl_mut (line 190) | pub unsafe fn ssl_mut(ssl: &SslRef) -> &mut SslRef {

FILE: pingora-cache/benches/lru_memory.rs
  constant ITEMS (line 23) | const ITEMS: usize = 5 * usize::pow(2, 20);
  function main (line 88) | fn main() {

FILE: pingora-cache/benches/lru_serde.rs
  constant ITEMS (line 22) | const ITEMS: usize = 5 * usize::pow(2, 20);
  function main (line 24) | fn main() {

FILE: pingora-cache/benches/simple_lru_memory.rs
  constant ITEMS (line 23) | const ITEMS: usize = 5 * usize::pow(2, 20);
  function main (line 70) | fn main() {

FILE: pingora-cache/src/cache_control.rs
  constant DELTA_SECONDS_OVERFLOW_VALUE (line 46) | pub const DELTA_SECONDS_OVERFLOW_VALUE: u32 = i32::MAX as u32;
  constant DELTA_SECONDS_OVERFLOW_DURATION (line 47) | pub const DELTA_SECONDS_OVERFLOW_DURATION: Duration =
  type DirectiveKey (line 51) | pub type DirectiveKey = String;
  type DirectiveValue (line 55) | pub struct DirectiveValue(pub Vec<u8>);
    method as_ref (line 58) | fn as_ref(&self) -> &[u8] {
    method parse_as_bytes (line 65) | pub fn parse_as_bytes(&self) -> &[u8] {
    method parse_as_str (line 73) | pub fn parse_as_str(&self) -> Result<&str> {
    method parse_as_delta_seconds (line 82) | pub fn parse_as_delta_seconds(&self) -> Result<u32> {
  type DirectiveMap (line 98) | pub type DirectiveMap = IndexMap<DirectiveKey, Option<DirectiveValue>>;
  type CacheControl (line 102) | pub struct CacheControl {
    method from_headers (line 178) | fn from_headers(headers: http::header::GetAll<HeaderValue>) -> Option<...
    method from_headers_named (line 205) | pub fn from_headers_named(header_name: &str, headers: &http::HeaderMap...
    method from_req_headers_named (line 214) | pub fn from_req_headers_named(header_name: &str, req_header: &ReqHeade...
    method from_req_headers (line 219) | pub fn from_req_headers(req_header: &ReqHeader) -> Option<Self> {
    method from_resp_headers_named (line 224) | pub fn from_resp_headers_named(header_name: &str, resp_header: &RespHe...
    method from_resp_headers (line 229) | pub fn from_resp_headers(resp_header: &RespHeader) -> Option<Self> {
    method has_key (line 234) | pub fn has_key(&self, key: &str) -> bool {
    method public (line 239) | pub fn public(&self) -> bool {
    method has_key_without_value (line 244) | fn has_key_without_value(&self, key: &str) -> bool {
    method private (line 254) | pub fn private(&self) -> bool {
    method get_field_names (line 258) | fn get_field_names(&self, key: &str) -> Option<ListValueIter<'_>> {
    method private_field_names (line 264) | pub fn private_field_names(&self) -> Option<ListValueIter<'_>> {
    method no_cache (line 269) | pub fn no_cache(&self) -> bool {
    method no_cache_field_names (line 274) | pub fn no_cache_field_names(&self) -> Option<ListValueIter<'_>> {
    method no_store (line 279) | pub fn no_store(&self) -> bool {
    method parse_delta_seconds (line 283) | fn parse_delta_seconds(&self, key: &str) -> Result<Option<u32>> {
    method max_age (line 292) | pub fn max_age(&self) -> Result<Option<u32>> {
    method s_maxage (line 297) | pub fn s_maxage(&self) -> Result<Option<u32>> {
    method stale_while_revalidate (line 302) | pub fn stale_while_revalidate(&self) -> Result<Option<u32>> {
    method stale_if_error (line 307) | pub fn stale_if_error(&self) -> Result<Option<u32>> {
    method must_revalidate (line 312) | pub fn must_revalidate(&self) -> bool {
    method proxy_revalidate (line 317) | pub fn proxy_revalidate(&self) -> bool {
    method only_if_cached (line 322) | pub fn only_if_cached(&self) -> bool {
  type Cacheable (line 109) | pub enum Cacheable {
  type ListValueIter (line 119) | pub struct ListValueIter<'a>(slice::Split<'a, u8, fn(&u8) -> bool>);
  function from (line 122) | pub fn from(value: &'a DirectiveValue) -> Self {
  function trim_ows (line 129) | fn trim_ows(bytes: &[u8]) -> &[u8] {
  type Item (line 144) | type Item = &'a [u8];
  method next (line 146) | fn next(&mut self) -> Option<Self::Item> {
  type InterpretCacheControl (line 409) | pub trait InterpretCacheControl {
    method is_cacheable (line 328) | fn is_cacheable(&self) -> Cacheable {
    method allow_caching_authorized_req (line 338) | fn allow_caching_authorized_req(&self) -> bool {
    method fresh_duration (line 345) | fn fresh_duration(&self) -> Option<Duration> {
    method serve_stale_while_revalidate_duration (line 359) | fn serve_stale_while_revalidate_duration(&self) -> Option<Duration> {
    method serve_stale_if_error_duration (line 370) | fn serve_stale_if_error_duration(&self) -> Option<Duration> {
    method strip_private_headers (line 380) | fn strip_private_headers(&self, resp_header: &mut ResponseHeader) {
    method is_cacheable (line 415) | fn is_cacheable(&self) -> Cacheable;
    method allow_caching_authorized_req (line 419) | fn allow_caching_authorized_req(&self) -> bool;
    method fresh_duration (line 425) | fn fresh_duration(&self) -> Option<Duration>;
    method serve_stale_while_revalidate_duration (line 435) | fn serve_stale_while_revalidate_duration(&self) -> Option<Duration>;
    method serve_stale_if_error_duration (line 445) | fn serve_stale_if_error_duration(&self) -> Option<Duration>;
    method strip_private_headers (line 449) | fn strip_private_headers(&self, resp_header: &mut ResponseHeader);
  function build_response (line 458) | fn build_response(cc_key: HeaderName, cc_value: &str) -> response::Parts {
  function test_simple_cache_control (line 468) | fn test_simple_cache_control() {
  function test_private_cache_control (line 476) | fn test_private_cache_control() {
  function test_directives_across_header_lines (line 485) | fn test_directives_across_header_lines() {
  function test_recognizes_semicolons_as_delimiters (line 499) | fn test_recognizes_semicolons_as_delimiters() {
  function test_unknown_directives (line 508) | fn test_unknown_directives() {
  function test_case_insensitive_directive_keys (line 529) | fn test_case_insensitive_directive_keys() {
  function test_non_ascii (line 561) | fn test_non_ascii() {
  function test_non_utf8_key (line 585) | fn test_non_utf8_key() {
  function test_non_utf8_value (line 604) | fn test_non_utf8_value() {
  function test_age_overflow (line 637) | fn test_age_overflow() {
  function test_fresh_sec (line 656) | fn test_fresh_sec() {
  function test_cacheability (line 672) | fn test_cacheability() {
  function test_no_cache (line 697) | fn test_no_cache() {
  function test_no_cache_field_names (line 705) | fn test_no_cache_field_names() {
  function test_strip_private_headers (line 746) | fn test_strip_private_headers() {
  function test_stale_while_revalidate (line 761) | fn test_stale_while_revalidate() {
  function test_stale_if_error (line 773) | fn test_stale_if_error() {
  function test_must_revalidate (line 785) | fn test_must_revalidate() {
  function test_proxy_revalidate (line 802) | fn test_proxy_revalidate() {
  function test_s_maxage_stale (line 819) | fn test_s_maxage_stale() {
  function test_authorized_request (line 835) | fn test_authorized_request() {
  function build_request (line 857) | fn build_request(cc_key: HeaderName, cc_value: &str) -> request::Parts {
  function test_request_only_if_cached (line 867) | fn test_request_only_if_cached() {

FILE: pingora-cache/src/eviction/lru.rs
  type Manager (line 40) | pub struct Manager<const N: usize>(Lru<CompactCacheKey, N>);
  type SerdeHelperNode (line 43) | struct SerdeHelperNode(CompactCacheKey, usize);
  function with_capacity (line 49) | pub fn with_capacity(limit: usize, capacity: usize) -> Self {
  function with_capacity_and_watermark (line 57) | pub fn with_capacity_and_watermark(
  function shards (line 66) | pub fn shards(&self) -> usize {
  function shard_weight (line 71) | pub fn shard_weight(&self, shard: usize) -> usize {
  function shard_len (line 76) | pub fn shard_len(&self, shard: usize) -> usize {
  function get_shard_for_key (line 84) | pub fn get_shard_for_key(&self, key: &CompactCacheKey) -> usize {
  function serialize_shard (line 89) | pub fn serialize_shard(&self, shard: usize) -> Result<Vec<u8>> {
  function deserialize_shard (line 117) | pub fn deserialize_shard(&self, buf: &[u8]) -> Result<()> {
  function peek_weight (line 129) | pub fn peek_weight(&self, item: &CompactCacheKey) -> Option<usize> {
  type InsertToManager (line 135) | struct InsertToManager<'a, const N: usize> {
  type Value (line 140) | type Value = ();
  function expecting (line 142) | fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Re...
  function visit_seq (line 146) | fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
  function u64key (line 159) | fn u64key(key: &CompactCacheKey) -> u64 {
  constant FILE_NAME (line 166) | const FILE_NAME: &str = "lru.data";
  function err_str_path (line 169) | fn err_str_path(s: &str, path: &Path) -> String {
  method total_size (line 175) | fn total_size(&self) -> usize {
  method total_items (line 178) | fn total_items(&self) -> usize {
  method evicted_size (line 181) | fn evicted_size(&self) -> usize {
  method evicted_items (line 184) | fn evicted_items(&self) -> usize {
  method admit (line 188) | fn admit(
  method increment_weight (line 203) | fn increment_weight(
  method remove (line 218) | fn remove(&self, item: &CompactCacheKey) {
  method access (line 223) | fn access(&self, item: &CompactCacheKey, size: usize, _fresh_until: Syst...
  method peek (line 233) | fn peek(&self, item: &CompactCacheKey) -> bool {
  method save (line 238) | async fn save(&self, dir_path: &str) -> Result<()> {
  method load (line 281) | async fn load(&self, dir_path: &str) -> Result<()> {
  function cleanup_temp_files (line 324) | fn cleanup_temp_files(dir_path: &str) {
  function test_admission (line 391) | fn test_admission() {
  function test_access (line 415) | fn test_access() {
  function test_remove (line 440) | fn test_remove() {
  function test_access_add (line 465) | fn test_access_add() {
  function test_admit_update (line 485) | fn test_admit_update() {
  function test_peek (line 516) | fn test_peek() {
  function test_serde (line 529) | fn test_serde() {
  function test_save_to_disk (line 559) | async fn test_save_to_disk() {
  function test_temp_file_cleanup (line 583) | async fn test_temp_file_cleanup() {

FILE: pingora-cache/src/eviction/mod.rs
  type EvictionManager (line 31) | pub trait EvictionManager: Send + Sync {
    method total_size (line 33) | fn total_size(&self) -> usize;
    method total_items (line 35) | fn total_items(&self) -> usize;
    method evicted_size (line 39) | fn evicted_size(&self) -> usize;
    method evicted_items (line 43) | fn evicted_items(&self) -> usize;
    method admit (line 53) | fn admit(
    method increment_weight (line 69) | fn increment_weight(
    method remove (line 79) | fn remove(&self, item: &CompactCacheKey);
    method access (line 87) | fn access(&self, item: &CompactCacheKey, size: usize, fresh_until: Sys...
    method peek (line 93) | fn peek(&self, item: &CompactCacheKey) -> bool;
    method save (line 101) | async fn save(&self, dir_path: &str) -> Result<()>;
    method load (line 104) | async fn load(&self, dir_path: &str) -> Result<()>;

FILE: pingora-cache/src/eviction/simple_lru.rs
  type Node (line 36) | struct Node {
  type Manager (line 44) | pub struct Manager {
    method new (line 56) | pub fn new(limit: usize) -> Self {
    method new_with_watermark (line 69) | pub fn new_with_watermark(limit: usize, items_watermark: Option<usize>...
    method insert (line 81) | fn insert(&self, hash_key: u64, node: CompactCacheKey, size: usize, re...
    method increase_weight (line 105) | fn increase_weight(&self, key: u64, delta: usize) {
    method over_limits (line 115) | fn over_limits(&self) -> bool {
    method evict (line 123) | fn evict(&self) -> Vec<CompactCacheKey> {
    method serialize (line 151) | fn serialize(&self) -> Result<Vec<u8>> {
    method deserialize (line 169) | fn deserialize(&self, buf: &[u8]) -> Result<()> {
  type InsertToManager (line 180) | struct InsertToManager<'a> {
  type Value (line 185) | type Value = ();
  function expecting (line 187) | fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Re...
  function visit_seq (line 191) | fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
  function u64key (line 204) | fn u64key(key: &CompactCacheKey) -> u64 {
  constant FILE_NAME (line 210) | const FILE_NAME: &str = "simple_lru.data";
  method total_size (line 214) | fn total_size(&self) -> usize {
  method total_items (line 217) | fn total_items(&self) -> usize {
  method evicted_size (line 220) | fn evicted_size(&self) -> usize {
  method evicted_items (line 223) | fn evicted_items(&self) -> usize {
  method admit (line 227) | fn admit(
  method increment_weight (line 238) | fn increment_weight(
  method remove (line 249) | fn remove(&self, item: &CompactCacheKey) {
  method access (line 258) | fn access(&self, item: &CompactCacheKey, size: usize, _fresh_until: Syst...
  method peek (line 268) | fn peek(&self, item: &CompactCacheKey) -> bool {
  method save (line 273) | async fn save(&self, dir_path: &str) -> Result<()> {
  method load (line 306) | async fn load(&self, dir_path: &str) -> Result<()> {
  function test_admission (line 330) | fn test_admission() {
  function test_access (line 354) | fn test_access() {
  function test_remove (line 379) | fn test_remove() {
  function test_access_add (line 404) | fn test_access_add() {
  function test_admit_update (line 424) | fn test_admit_update() {
  function test_serde (line 455) | fn test_serde() {
  function test_save_to_disk (line 485) | async fn test_save_to_disk() {
  function test_watermark_eviction (line 515) | fn test_watermark_eviction() {

FILE: pingora-cache/src/filters.rs
  function request_cacheable (line 28) | pub fn request_cacheable(req_header: &ReqHeader) -> bool {
  function resp_cacheable (line 37) | pub fn resp_cacheable(
  function calculate_fresh_until (line 72) | pub fn calculate_fresh_until(
  function calculate_expires_header_time (line 120) | pub fn calculate_expires_header_time(resp_header: &RespHeader) -> Option...
  function calculate_serve_stale_durations (line 145) | pub fn calculate_serve_stale_durations(
  function request_filter (line 180) | pub fn request_filter(req: &mut RequestHeader, meta: Option<&CacheMeta>) {
  function init_log (line 220) | fn init_log() {
  constant DEFAULTS (line 224) | const DEFAULTS: CacheMetaDefaults = CacheMetaDefaults::new(
  constant BYPASS_CACHE_DEFAULTS (line 239) | const BYPASS_CACHE_DEFAULTS: CacheMetaDefaults = CacheMetaDefaults::new(...
  function build_response (line 241) | fn build_response(status: u16, headers: &[(HeaderName, &str)]) -> Respon...
  function resp_cacheable_wrapper (line 249) | fn resp_cacheable_wrapper(
  function test_resp_cacheable (line 267) | fn test_resp_cacheable() {
  function test_resp_uncacheable_directives (line 289) | fn test_resp_uncacheable_directives() {
  function test_resp_cache_authorization (line 306) | fn test_resp_cache_authorization() {
  function test_resp_zero_max_age (line 340) | fn test_resp_zero_max_age() {
  function test_resp_expires (line 352) | fn test_resp_expires() {
  function test_resp_past_expires (line 382) | fn test_resp_past_expires() {
  function test_resp_nonstandard_expires (line 393) | fn test_resp_nonstandard_expires() {
  function test_resp_multiple_expires (line 422) | fn test_resp_multiple_expires() {
  function test_resp_cache_control_with_expires (line 460) | fn test_resp_cache_control_with_expires() {
  function test_resp_stale_while_revalidate (line 480) | fn test_resp_stale_while_revalidate() {
  function test_resp_stale_if_error (line 519) | fn test_resp_stale_if_error() {
  function test_resp_status_cache_defaults (line 575) | fn test_resp_status_cache_defaults() {
  function test_resp_cache_no_cache_fields (line 646) | fn test_resp_cache_no_cache_fields() {

FILE: pingora-cache/src/hashtable.rs
  type ConcurrentHashTable (line 24) | pub struct ConcurrentHashTable<V, const N: usize> {
  function get_shard (line 29) | fn get_shard(key: u128, n_shards: usize) -> usize {
  function new (line 37) | pub fn new() -> Self {
  function get (line 42) | pub fn get(&self, key: u128) -> &RwLock<HashMap<u128, V>> {
  function get_shard_at_idx (line 47) | pub fn get_shard_at_idx(&self, idx: usize) -> Option<&RwLock<HashMap<u12...
  function read (line 52) | pub fn read(&self, key: u128) -> RwLockReadGuard<'_, HashMap<u128, V>> {
  function write (line 56) | pub fn write(&self, key: u128) -> RwLockWriteGuard<'_, HashMap<u128, V>> {
  function for_each (line 61) | pub fn for_each<F>(&self, mut f: F)
  method default (line 80) | fn default() -> Self {
  type LruShard (line 86) | pub struct LruShard<V>(RwLock<LruCache<u128, V>>);
  method default (line 88) | fn default() -> Self {
  type ConcurrentLruCache (line 95) | pub struct ConcurrentLruCache<V, const N: usize> {
  function new (line 103) | pub fn new(shard_capacity: usize) -> Self {
  function get (line 117) | pub fn get(&self, key: u128) -> &RwLock<LruCache<u128, V>> {
  function read (line 122) | pub fn read(&self, key: u128) -> RwLockReadGuard<'_, LruCache<u128, V>> {
  function write (line 126) | pub fn write(&self, key: u128) -> RwLockWriteGuard<'_, LruCache<u128, V>> {

FILE: pingora-cache/src/key.rs
  constant KEY_SIZE (line 23) | const KEY_SIZE: usize = 16;
  type HashBinary (line 26) | pub type HashBinary = [u8; KEY_SIZE];
  function hex2str (line 28) | fn hex2str(hex: &[u8]) -> String {
  function str2hex (line 40) | pub fn str2hex(s: &str) -> Option<HashBinary> {
  type CacheHashKey (line 51) | pub trait CacheHashKey {
    method primary_bin (line 53) | fn primary_bin(&self) -> HashBinary;
    method variance_bin (line 58) | fn variance_bin(&self) -> Option<HashBinary>;
    method combined_bin (line 61) | fn combined_bin(&self) -> HashBinary {
    method user_tag (line 77) | fn user_tag(&self) -> &str;
    method primary (line 80) | fn primary(&self) -> String {
    method variance (line 85) | fn variance(&self) -> Option<String> {
    method combined (line 90) | fn combined(&self) -> String {
    method primary_bin (line 167) | fn primary_bin(&self) -> HashBinary {
    method variance_bin (line 171) | fn variance_bin(&self) -> Option<HashBinary> {
    method user_tag (line 175) | fn user_tag(&self) -> &str {
    method primary_bin (line 256) | fn primary_bin(&self) -> HashBinary {
    method variance_bin (line 264) | fn variance_bin(&self) -> Option<HashBinary> {
    method user_tag (line 268) | fn user_tag(&self) -> &str {
  type CacheKey (line 97) | pub struct CacheKey {
    method set_variance_key (line 116) | pub fn set_variance_key(&mut self, key: HashBinary) {
    method get_variance_key (line 121) | pub fn get_variance_key(&self) -> Option<&HashBinary> {
    method remove_variance_key (line 126) | pub fn remove_variance_key(&mut self) {
    method set_primary_bin_override (line 131) | pub fn set_primary_bin_override(&mut self, key: HashBinary) {
    method primary_key_str (line 136) | pub fn primary_key_str(&self) -> Option<&str> {
    method namespace_str (line 141) | pub fn namespace_str(&self) -> Option<&str> {
    method primary_hasher (line 208) | fn primary_hasher(&self) -> Blake2b128 {
    method new (line 218) | pub fn new<B1, B2, S>(namespace: B1, primary: B2, user_tag: S) -> Self
    method namespace (line 235) | pub fn namespace(&self) -> &[u8] {
    method primary_key (line 240) | pub fn primary_key(&self) -> &[u8] {
    method to_compact (line 245) | pub fn to_compact(&self) -> CompactCacheKey {
  type CompactCacheKey (line 149) | pub struct CompactCacheKey {
  method fmt (line 157) | fn fmt(&self, f: &mut Formatter) -> FmtResult {
  type Blake2b128 (line 189) | pub(crate) type Blake2b128 = Blake2b<blake2::digest::consts::U16>;
  function hash_u8 (line 192) | pub fn hash_u8(key: &str) -> u8 {
  function hash_key (line 200) | pub fn hash_key<K: AsRef<[u8]>>(key: K) -> HashBinary {
  function test_cache_key_hash (line 278) | fn test_cache_key_hash() {
  function test_cache_key_hash_override (line 298) | fn test_cache_key_hash_override() {
  function test_cache_key_vary_hash (line 329) | fn test_cache_key_vary_hash() {
  function test_cache_key_vary_hash_override (line 352) | fn test_cache_key_vary_hash_override() {
  function test_hex_str (line 375) | fn test_hex_str() {
  function test_primary_key_str_valid_utf8 (line 388) | fn test_primary_key_str_valid_utf8() {
  function test_primary_key_str_invalid_utf8 (line 405) | fn test_primary_key_str_invalid_utf8() {

FILE: pingora-cache/src/lib.rs
  type HttpCache (line 62) | pub struct HttpCache {
    method new (line 326) | pub fn new() -> Self {
    method enabled (line 335) | pub fn enabled(&self) -> bool {
    method bypassing (line 340) | pub fn bypassing(&self) -> bool {
    method phase (line 345) | pub fn phase(&self) -> CachePhase {
    method upstream_used (line 352) | pub fn upstream_used(&self) -> bool {
    method storage_type_is (line 362) | pub fn storage_type_is<T: 'static>(&self) -> bool {
    method release_write_lock (line 379) | pub fn release_write_lock(&mut self, reason: NoCacheReason) {
    method disable (line 417) | pub fn disable(&mut self, reason: NoCacheReason) {
    method bypass (line 462) | pub fn bypass(&mut self) {
    method enable (line 485) | pub fn enable(
    method set_cache_lock (line 529) | pub fn set_cache_lock(
    method enable_tracing (line 560) | pub fn enable_tracing(&mut self, parent_span: trace::Span) {
    method get_cache_span (line 567) | pub fn get_cache_span(&self) -> Option<trace::SpanHandle> {
    method get_miss_span (line 574) | pub fn get_miss_span(&self) -> Option<trace::SpanHandle> {
    method get_hit_span (line 581) | pub fn get_hit_span(&self) -> Option<trace::SpanHandle> {
    method inner_enabled_mut (line 589) | fn inner_enabled_mut(&mut self) -> &mut HttpCacheInnerEnabled {
    method inner_enabled (line 594) | fn inner_enabled(&self) -> &HttpCacheInnerEnabled {
    method inner_mut (line 600) | fn inner_mut(&mut self) -> &mut HttpCacheInner {
    method inner (line 605) | fn inner(&self) -> &HttpCacheInner {
    method set_cache_key (line 612) | pub fn set_cache_key(&mut self, key: CacheKey) {
    method cache_key (line 625) | pub fn cache_key(&self) -> &CacheKey {
    method max_file_size_bytes (line 639) | pub fn max_file_size_bytes(&self) -> Option<usize> {
    method set_max_file_size_bytes (line 658) | pub fn set_max_file_size_bytes(&mut self, max_file_size_bytes: usize) {
    method track_body_bytes_for_max_file_size (line 677) | pub fn track_body_bytes_for_max_file_size(&mut self, bytes_len: usize)...
    method exceeded_max_file_size (line 696) | pub fn exceeded_max_file_size(&self) -> bool {
    method cache_found (line 716) | pub fn cache_found(&mut self, meta: CacheMeta, hit_handler: HitHandler...
    method cache_miss (line 773) | pub fn cache_miss(&mut self) {
    method hit_handler (line 794) | pub fn hit_handler(&mut self) -> &mut HitHandler {
    method miss_body_reader (line 809) | pub fn miss_body_reader(&mut self) -> Option<&mut HitHandler> {
    method support_streaming_partial_write (line 828) | pub fn support_streaming_partial_write(&self) -> Option<bool> {
    method finish_hit_handler (line 842) | pub async fn finish_hit_handler(&mut self) -> Result<()> {
    method set_miss_handler (line 874) | pub async fn set_miss_handler(&mut self) -> Result<()> {
    method miss_handler (line 935) | pub fn miss_handler(&mut self) -> Option<&mut MissHandler> {
    method finish_miss_handler (line 950) | pub async fn finish_miss_handler(&mut self) -> Result<()> {
    method set_cache_meta (line 1008) | pub fn set_cache_meta(&mut self, meta: CacheMeta) {
    method revalidate_cache_meta (line 1028) | pub async fn revalidate_cache_meta(&mut self, mut meta: CacheMeta) -> ...
    method revalidate_merge_header (line 1085) | pub fn revalidate_merge_header(&mut self, resp: &RespHeader) -> Respon...
    method revalidate_uncacheable (line 1130) | pub fn revalidate_uncacheable(&mut self, header: ResponseHeader, reaso...
    method set_stale_updating (line 1145) | pub fn set_stale_updating(&mut self) {
    method update_variance (line 1157) | pub fn update_variance(&mut self, variance: Option<HashBinary>) {
    method cache_meta (line 1222) | pub fn cache_meta(&self) -> &CacheMeta {
    method maybe_cache_meta (line 1251) | pub fn maybe_cache_meta(&self) -> Option<&CacheMeta> {
    method maybe_cache_key (line 1268) | pub fn maybe_cache_key(&self) -> Option<&CacheKey> {
    method cache_lookup (line 1282) | pub async fn cache_lookup(&mut self) -> Result<Option<(CacheMeta, HitH...
    method cache_vary_lookup (line 1328) | pub fn cache_vary_lookup(&mut self, variance: HashBinary, meta: &Cache...
    method is_cache_locked (line 1371) | pub fn is_cache_locked(&self) -> bool {
    method is_cache_lock_writer (line 1383) | pub fn is_cache_lock_writer(&self) -> bool {
    method take_write_lock (line 1396) | pub fn take_write_lock(&mut self) -> (WritePermit, &'static CacheKeyLo...
    method set_write_lock (line 1420) | pub fn set_write_lock(&mut self, write_lock: WritePermit) {
    method has_staled_asset (line 1427) | fn has_staled_asset(&self) -> bool {
    method can_serve_stale_error (line 1432) | pub fn can_serve_stale_error(&self) -> bool {
    method can_serve_stale_updating (line 1437) | pub fn can_serve_stale_updating(&self) -> bool {
    method cache_lock_wait (line 1447) | pub async fn cache_lock_wait(&mut self) -> LockStatus {
    method lock_duration (line 1486) | pub fn lock_duration(&self) -> Option<Duration> {
    method lookup_duration (line 1491) | pub fn lookup_duration(&self) -> Option<Duration> {
    method purge (line 1498) | pub async fn purge(&self) -> Result<bool> {
    method spawn_async_purge (line 1515) | pub fn spawn_async_purge(
    method purge_impl (line 1538) | async fn purge_impl(
    method cacheable_prediction (line 1561) | pub fn cacheable_prediction(&self) -> bool {
    method response_became_cacheable (line 1571) | pub fn response_became_cacheable(&self) {
    method response_became_uncacheable (line 1579) | pub fn response_became_uncacheable(&self, reason: NoCacheReason) {
    method tag_as_subrequest (line 1586) | pub fn tag_as_subrequest(&mut self) {
  type CachePhase (line 71) | pub enum CachePhase {
    method as_str (line 99) | pub fn as_str(&self) -> &'static str {
  type NoCacheReason (line 118) | pub enum NoCacheReason {
    method as_str (line 154) | pub fn as_str(&self) -> &'static str {
  type HttpCacheDigest (line 175) | pub struct HttpCacheDigest {
    method add_lookup_duration (line 187) | fn add_lookup_duration(&mut self, extra_lookup_duration: Duration) {
    method add_lock_duration (line 191) | fn add_lock_duration(&mut self, extra_lock_duration: Duration) {
  function add_duration_to_opt (line 182) | fn add_duration_to_opt(target_opt: &mut Option<Duration>, to_add: Durati...
  type RespCacheable (line 200) | pub enum RespCacheable {
    method is_cacheable (line 208) | pub fn is_cacheable(&self) -> bool {
    method unwrap_meta (line 215) | pub fn unwrap_meta(self) -> CacheMeta {
  type ForcedFreshness (line 227) | pub enum ForcedFreshness {
  type HitStatus (line 244) | pub enum HitStatus {
    method as_str (line 267) | pub fn as_str(&self) -> &'static str {
    method is_fresh (line 272) | pub fn is_fresh(&self) -> bool {
    method is_treated_as_miss (line 281) | pub fn is_treated_as_miss(self) -> bool {
  type LockCtx (line 286) | pub struct LockCtx {
  type HttpCacheInnerEnabled (line 293) | struct HttpCacheInnerEnabled {
  type HttpCacheInner (line 305) | struct HttpCacheInner {
  type CacheOptionOverrides (line 318) | pub struct CacheOptionOverrides {

FILE: pingora-cache/src/lock.rs
  type CacheKeyLockImpl (line 25) | pub type CacheKeyLockImpl = dyn CacheKeyLock + Send + Sync;
  type CacheKeyLock (line 27) | pub trait CacheKeyLock {
    method lock (line 35) | fn lock(&self, key: &CacheKey, stale_writer: bool) -> Locked;
    method release (line 41) | fn release(&self, key: &CacheKey, permit: WritePermit, reason: LockSta...
    method trace_lock_wait (line 44) | fn trace_lock_wait(&self, span: &mut Span, _read_lock: &ReadLock, lock...
    method custom_lock_status (line 50) | fn custom_lock_status(&self, _custom_no_cache: &'static str) -> LockSt...
    method lock (line 110) | fn lock(&self, key: &CacheKey, stale_writer: bool) -> Locked {
    method release (line 148) | fn release(&self, key: &CacheKey, mut permit: WritePermit, reason: Loc...
  constant N_SHARDS (line 57) | const N_SHARDS: usize = 16;
  type CacheLock (line 61) | pub struct CacheLock {
    method new_boxed (line 89) | pub fn new_boxed(age_timeout: Duration) -> Box<Self> {
    method new (line 101) | pub fn new(age_timeout_default: Duration) -> Self {
  type Locked (line 69) | pub enum Locked {
    method is_write (line 78) | pub fn is_write(&self) -> bool {
  type LockStatus (line 175) | pub enum LockStatus {
    method from (line 208) | fn from(v: u8) -> Self {
  function from (line 194) | fn from(l: LockStatus) -> u8 {
  type LockCore (line 214) | pub struct LockCore {
    method new_arc (line 225) | pub fn new_arc(timeout: Duration, stale_writer: bool, extensions: Exte...
    method locked (line 236) | pub fn locked(&self) -> bool {
    method unlock (line 240) | pub fn unlock(&self, reason: LockStatus) {
    method lock_status (line 251) | pub fn lock_status(&self) -> LockStatus {
    method stale_writer (line 256) | pub fn stale_writer(&self) -> bool {
    method extensions (line 260) | pub fn extensions(&self) -> &Extensions {
  type ReadLock (line 269) | pub struct ReadLock(Arc<LockCore>);
    method wait (line 273) | pub async fn wait(&self) {
    method locked (line 305) | pub fn locked(&self) -> bool {
    method expired (line 310) | pub fn expired(&self) -> bool {
    method lock_status (line 317) | pub fn lock_status(&self) -> LockStatus {
    method extensions (line 326) | pub fn extensions(&self) -> &Extensions {
  type WritePermit (line 333) | pub struct WritePermit {
    method new (line 340) | pub fn new(
    method stale_writer (line 357) | pub fn stale_writer(&self) -> bool {
    method unlock (line 361) | pub fn unlock(&mut self, reason: LockStatus) {
    method lock_status (line 366) | pub fn lock_status(&self) -> LockStatus {
    method extensions (line 370) | pub fn extensions(&self) -> &Extensions {
  method drop (line 376) | fn drop(&mut self) {
  type LockStub (line 386) | pub struct LockStub(pub Arc<LockCore>);
    method read_lock (line 388) | pub fn read_lock(&self) -> ReadLock {
    method extensions (line 392) | pub fn extensions(&self) -> &Extensions {
  function test_get_release (line 403) | fn test_get_release() {
  function test_lock (line 421) | async fn test_lock() {
  function test_lock_timeout (line 442) | async fn test_lock_timeout() {
  function test_lock_expired_release (line 487) | async fn test_lock_expired_release() {
  function test_lock_expired_no_reader (line 535) | async fn test_lock_expired_no_reader() {
  function test_lock_concurrent (line 559) | async fn test_lock_concurrent() {

FILE: pingora-cache/src/max_file_size.rs
  constant ERR_RESPONSE_TOO_LARGE (line 20) | pub const ERR_RESPONSE_TOO_LARGE: ErrorType = ErrorType::Custom("respons...
  type MaxFileSizeTracker (line 25) | pub(crate) struct MaxFileSizeTracker {
    method new (line 32) | pub fn new(max_size: usize) -> MaxFileSizeTracker {
    method add_body_bytes (line 41) | pub fn add_body_bytes(&mut self, bytes: usize) -> bool {
    method max_file_size_bytes (line 46) | pub fn max_file_size_bytes(&self) -> usize {
    method allow_caching (line 50) | pub fn allow_caching(&self) -> bool {

FILE: pingora-cache/src/memory.rs
  type BinaryMeta (line 36) | type BinaryMeta = (Vec<u8>, Vec<u8>);
  type CacheObject (line 38) | pub(crate) struct CacheObject {
  type TempObject (line 43) | pub(crate) struct TempObject {
    method new (line 51) | fn new(meta: BinaryMeta) -> Self {
    method make_cache_object (line 60) | fn make_cache_object(&self) -> CacheObject {
  type MemCache (line 70) | pub struct MemCache {
    method new (line 78) | pub fn new() -> Self {
  type MemHitHandler (line 87) | pub enum MemHitHandler {
  type PartialState (line 93) | enum PartialState {
  type CompleteHit (line 98) | pub struct CompleteHit {
    method get (line 106) | fn get(&mut self) -> Option<Bytes> {
    method seek (line 117) | fn seek(&mut self, start: usize, end: Option<usize>) -> Result<()> {
  type PartialHit (line 135) | pub struct PartialHit {
    method read (line 142) | async fn read(&mut self) -> Option<Bytes> {
  method read_body (line 177) | async fn read_body(&mut self) -> Result<Option<Bytes>> {
  method finish (line 183) | async fn finish(
  method can_seek (line 192) | fn can_seek(&self) -> bool {
  method seek (line 199) | fn seek(&mut self, start: usize, end: Option<usize>) -> Result<()> {
  method should_count_access (line 209) | fn should_count_access(&self) -> bool {
  method get_eviction_weight (line 217) | fn get_eviction_weight(&self) -> usize {
  method as_any (line 226) | fn as_any(&self) -> &(dyn Any + Send + Sync) {
  method as_any_mut (line 230) | fn as_any_mut(&mut self) -> &mut (dyn Any + Send + Sync) {
  type MemMissHandler (line 235) | pub struct MemMissHandler {
  method write_body (line 249) | async fn write_body(&mut self, data: bytes::Bytes, eof: bool) -> Result<...
  method finish (line 265) | async fn finish(self: Box<Self>) -> Result<MissFinishType> {
  method streaming_write_tag (line 284) | fn streaming_write_tag(&self) -> Option<&[u8]> {
  method drop (line 290) | fn drop(&mut self) {
  function hit_from_temp_obj (line 298) | fn hit_from_temp_obj(temp_obj: &TempObject) -> Result<Option<(CacheMeta,...
  method lookup (line 311) | async fn lookup(
  method lookup_streaming_write (line 342) | async fn lookup_streaming_write(
  method get_miss_handler (line 362) | async fn get_miss_handler(
  method purge (line 388) | async fn purge(
  method update_meta (line 402) | async fn update_meta(
  method support_streaming_partial_write (line 417) | fn support_streaming_partial_write(&self) -> bool {
  method as_any (line 421) | fn as_any(&self) -> &(dyn Any + Send + Sync) {
  function gen_meta (line 432) | fn gen_meta() -> CacheMeta {
  function test_write_then_read (line 447) | async fn test_write_then_read() {
  function test_read_range (line 484) | async fn test_read_range() {
  function test_write_while_read (line 527) | async fn test_write_while_read() {
  function test_purge_partial (line 596) | async fn test_purge_partial() {
  function test_purge_complete (line 623) | async fn test_purge_complete() {

FILE: pingora-cache/src/meta.rs
  type InternalMeta (line 29) | pub(crate) type InternalMeta = internal_meta::InternalMetaLatest;
  type InternalMetaLatest (line 33) | pub(crate) type InternalMetaLatest = InternalMetaV2;
  type InternalMetaV0 (line 36) | pub(crate) struct InternalMetaV0 {
    method serialize (line 46) | fn serialize(&self) -> Result<Vec<u8>> {
    method deserialize (line 50) | fn deserialize(buf: &[u8]) -> Result<Self> {
  type InternalMetaV1 (line 57) | pub(crate) struct InternalMetaV1 {
    constant VERSION (line 68) | pub const VERSION: u8 = 1;
    method serialize (line 71) | pub fn serialize(&self) -> Result<Vec<u8>> {
    method deserialize (line 76) | fn deserialize(buf: &[u8]) -> Result<Self> {
  type InternalMetaV2 (line 83) | pub(crate) struct InternalMetaV2 {
    constant VERSION (line 119) | pub const VERSION: u8 = 2;
    method serialize (line 121) | pub fn serialize(&self) -> Result<Vec<u8>> {
    method deserialize (line 126) | fn deserialize(buf: &[u8]) -> Result<Self> {
    method from (line 133) | fn from(v0: InternalMetaV0) -> Self {
    method from (line 147) | fn from(v1: InternalMetaV1) -> Self {
  method default (line 103) | fn default() -> Self {
  function deserialize (line 161) | pub(crate) fn deserialize(buf: &[u8]) -> Result<InternalMetaLatest> {
  function test_internal_meta_serde_v0 (line 199) | fn test_internal_meta_serde_v0() {
  function test_internal_meta_serde_v1 (line 212) | fn test_internal_meta_serde_v1() {
  function test_internal_meta_serde_v2 (line 226) | fn test_internal_meta_serde_v2() {
  function test_internal_meta_serde_across_versions (line 237) | fn test_internal_meta_serde_across_versions() {
  type InternalMetaV2Base (line 267) | struct InternalMetaV2Base {
    constant VERSION (line 277) | pub const VERSION: u8 = 2;
    method serialize (line 278) | pub fn serialize(&self) -> Result<Vec<u8>> {
    method deserialize (line 282) | fn deserialize(buf: &[u8]) -> Result<Self> {
  type InternalMetaV2BaseWithVariance (line 290) | struct InternalMetaV2BaseWithVariance {
    constant VERSION (line 318) | pub const VERSION: u8 = 2;
    method serialize (line 319) | pub fn serialize(&self) -> Result<Vec<u8>> {
    method deserialize (line 323) | fn deserialize(buf: &[u8]) -> Result<Self> {
  method default (line 303) | fn default() -> Self {
  function test_internal_meta_serde_v2_extend_fields_variance (line 330) | fn test_internal_meta_serde_v2_extend_fields_variance() {
  function test_internal_meta_serde_v2_extend_fields_epoch_override (line 359) | fn test_internal_meta_serde_v2_extend_fields_epoch_override() {
  type CacheMetaInner (line 412) | pub(crate) struct CacheMetaInner {
  type CacheMeta (line 423) | pub struct CacheMeta(pub(crate) Box<CacheMetaInner>);
    method new (line 427) | pub fn new(
    method created (line 450) | pub fn created(&self) -> SystemTime {
    method updated (line 457) | pub fn updated(&self) -> SystemTime {
    method epoch (line 465) | pub fn epoch(&self) -> SystemTime {
    method epoch_override (line 470) | pub fn epoch_override(&self) -> Option<SystemTime> {
    method set_epoch_override (line 478) | pub fn set_epoch_override(&mut self, epoch: SystemTime) {
    method remove_epoch_override (line 483) | pub fn remove_epoch_override(&mut self) {
    method is_fresh (line 488) | pub fn is_fresh(&self, time: SystemTime) -> bool {
    method fresh_sec (line 497) | pub fn fresh_sec(&self) -> u64 {
    method fresh_until (line 510) | pub fn fresh_until(&self) -> SystemTime {
    method age (line 517) | pub fn age(&self) -> Duration {
    method stale_while_revalidate_sec (line 525) | pub fn stale_while_revalidate_sec(&self) -> u32 {
    method stale_if_error_sec (line 530) | pub fn stale_if_error_sec(&self) -> u32 {
    method serve_stale_while_revalidate (line 538) | pub fn serve_stale_while_revalidate(&self, time: SystemTime) -> bool {
    method serve_stale_if_error (line 546) | pub fn serve_stale_if_error(&self, time: SystemTime) -> bool {
    method disable_serve_stale (line 551) | pub fn disable_serve_stale(&mut self) {
    method variance (line 557) | pub fn variance(&self) -> Option<HashBinary> {
    method set_variance_key (line 562) | pub fn set_variance_key(&mut self, variance_key: HashBinary) {
    method set_variance (line 567) | pub fn set_variance(&mut self, variance: HashBinary) {
    method remove_variance (line 572) | pub fn remove_variance(&mut self) {
    method response_header (line 577) | pub fn response_header(&self) -> &ResponseHeader {
    method response_header_mut (line 582) | pub fn response_header_mut(&mut self) -> &mut ResponseHeader {
    method extensions (line 587) | pub fn extensions(&self) -> &Extensions {
    method extensions_mut (line 592) | pub fn extensions_mut(&mut self) -> &mut Extensions {
    method response_header_copy (line 597) | pub fn response_header_copy(&self) -> ResponseHeader {
    method headers (line 602) | pub fn headers(&self) -> &HMap {
    method can_serve_stale (line 606) | fn can_serve_stale(&self, serve_stale_sec: u32, time: SystemTime) -> b...
    method serialize (line 624) | pub fn serialize(&self) -> Result<(Vec<u8>, Vec<u8>)> {
    method deserialize (line 632) | pub fn deserialize(internal: &[u8], header: &[u8]) -> Result<Self> {
  type FreshDurationByStatusFn (line 646) | pub type FreshDurationByStatusFn = fn(StatusCode) -> Option<Duration>;
  type CacheMetaDefaults (line 649) | pub struct CacheMetaDefaults {
    method new (line 659) | pub const fn new(
    method fresh_sec (line 674) | pub fn fresh_sec(&self, resp_status: StatusCode) -> Option<Duration> {
    method serve_stale_while_revalidate_sec (line 684) | pub fn serve_stale_while_revalidate_sec(&self) -> u32 {
    method serve_stale_if_error_sec (line 689) | pub fn serve_stale_if_error_sec(&self) -> u32 {
  function header_serialize (line 710) | pub(crate) fn header_serialize(header: &ResponseHeader) -> Result<Vec<u8...
  function header_deserialize (line 714) | pub(crate) fn header_deserialize<T: AsRef<[u8]>>(buf: T) -> Result<Respo...
  function set_compression_dict_path (line 723) | pub fn set_compression_dict_path(path: &str) -> bool {
  function set_compression_dict_content (line 742) | pub fn set_compression_dict_content(content: Cow<'static, [u8]>) -> bool {
  function test_cache_meta_age_without_override (line 752) | fn test_cache_meta_age_without_override() {
  function test_cache_meta_age_with_epoch_override_past (line 767) | fn test_cache_meta_age_with_epoch_override_past() {
  function test_cache_meta_age_with_epoch_override_future (line 787) | fn test_cache_meta_age_with_epoch_override_future() {
  function test_cache_meta_fresh_sec (line 802) | fn test_cache_meta_fresh_sec() {

FILE: pingora-cache/src/predictor.rs
  type CustomReasonPredicate (line 19) | pub type CustomReasonPredicate = fn(&'static str) -> bool;
  type Predictor (line 30) | pub struct Predictor<const N_SHARDS: usize> {
  type CacheablePredictor (line 41) | pub trait CacheablePredictor {
    method cacheable_prediction (line 43) | fn cacheable_prediction(&self, key: &CacheKey) -> bool;
    method mark_cacheable (line 47) | fn mark_cacheable(&self, key: &CacheKey) -> bool;
    method mark_uncacheable (line 53) | fn mark_uncacheable(&self, key: &CacheKey, reason: NoCacheReason) -> O...
    method cacheable_prediction (line 87) | fn cacheable_prediction(&self, key: &CacheKey) -> bool {
    method mark_cacheable (line 97) | fn mark_cacheable(&self, key: &CacheKey) -> bool {
    method mark_uncacheable (line 115) | fn mark_uncacheable(&self, key: &CacheKey, reason: NoCacheReason) -> O...
  function new (line 72) | pub fn new(
  function test_mark_cacheability (line 160) | fn test_mark_cacheability() {
  function test_custom_skip_predicate (line 182) | fn test_custom_skip_predicate() {
  function test_mark_uncacheable_lru (line 207) | fn test_mark_uncacheable_lru() {

FILE: pingora-cache/src/put.rs
  type CachePut (line 28) | pub trait CachePut {
    method cacheable (line 30) | fn cacheable(&self, response: ResponseHeader) -> RespCacheable {
    method cache_defaults (line 36) | fn cache_defaults() -> &'static CacheMetaDefaults;
    method trace_header (line 39) | fn trace_header(&mut self, _response: &ResponseHeader) {}
    method cache_defaults (line 247) | fn cache_defaults() -> &'static CacheMetaDefaults {
  type CachePutCtx (line 45) | pub struct CachePutCtx<C: CachePut> {
  function new (line 61) | pub fn new(
  function set_max_file_size_bytes (line 82) | pub fn set_max_file_size_bytes(&mut self, max_file_size_bytes: usize) {
  function put_header (line 86) | async fn put_header(&mut self, meta: CacheMeta) -> Result<()> {
  function put_body (line 98) | async fn put_body(&mut self, data: Bytes, eof: bool) -> Result<()> {
  function finish (line 118) | async fn finish(&mut self) -> Result<()> {
  function trace_header (line 153) | fn trace_header(&mut self, header: &ResponseHeader) {
  function do_cache_put (line 168) | async fn do_cache_put(&mut self, data: &[u8]) -> Result<Option<NoCacheRe...
  function cache_put (line 214) | pub async fn cache_put(
  type TestCachePut (line 245) | struct TestCachePut();
  type TestCachePutCtx (line 254) | type TestCachePutCtx = CachePutCtx<TestCachePut>;
  function test_cache_put (line 258) | async fn test_cache_put() {
  function test_cache_put_uncacheable (line 292) | async fn test_cache_put_uncacheable() {
  function test_cache_put_204_invalid_body (line 313) | async fn test_cache_put_204_invalid_body() {
  function test_cache_put_extra_body (line 353) | async fn test_cache_put_extra_body() {
  constant INCOMPLETE_BODY (line 405) | pub const INCOMPLETE_BODY: ErrorType = ErrorType::new("IncompleteHttpBod...
  constant MAX_HEADERS (line 407) | const MAX_HEADERS: usize = 256;
  constant INIT_HEADER_BUF_SIZE (line 408) | const INIT_HEADER_BUF_SIZE: usize = 4096;
  type ParseState (line 411) | enum ParseState {
    method is_done (line 421) | fn is_done(&self) -> bool {
    method read_header (line 424) | fn read_header(&self) -> bool {
    method read_body (line 427) | fn read_body(&self) -> bool {
  type ResponseParse (line 435) | pub(super) struct ResponseParse {
    method new (line 442) | pub fn new() -> Self {
    method inject_data (line 450) | pub fn inject_data(&mut self, data: &[u8]) -> Result<Vec<HttpTask>> {
    method put_data (line 482) | fn put_data(&mut self, data: &[u8]) {
    method parse_header (line 490) | fn parse_header(&mut self) -> Result<Option<ResponseHeader>> {
    method parse_body (line 533) | fn parse_body(&mut self) -> Result<Option<Bytes>> {
    method finish (line 565) | pub fn finish(&mut self) -> Result<()> {
  function body_type (line 577) | fn body_type(resp: &ResponseHeader) -> ParseState {
  function test_basic_response (line 611) | fn test_basic_response() {
  function test_partial_response_headers (line 633) | fn test_partial_response_headers() {
  function test_invalid_headers (line 653) | fn test_invalid_headers() {
  function test_body_content_length (line 666) | fn test_body_content_length() {
  function test_body_chunked (line 695) | fn test_body_chunked() {
  function test_body_content_length_early (line 716) | fn test_body_content_length_early() {
  function test_body_content_length_more_data (line 737) | fn test_body_content_length_more_data() {
  function test_body_chunked_partial_chunk (line 759) | fn test_body_chunked_partial_chunk() {
  function test_no_body_content_length (line 786) | fn test_no_body_content_length() {
  function test_no_body_304_no_content_length (line 802) | fn test_no_body_304_no_content_length() {
  function test_204_with_chunked_body (line 818) | fn test_204_with_chunked_body() {
  function test_204_with_content_length (line 837) | fn test_204_with_content_length() {
  function test_200_with_zero_content_length_more_data (line 856) | fn test_200_with_zero_content_length_more_data() {

FILE: pingora-cache/src/storage.rs
  type PurgeType (line 27) | pub enum PurgeType {
  type Storage (line 36) | pub trait Storage {
    method lookup (line 40) | async fn lookup(
    method lookup_streaming_write (line 58) | async fn lookup_streaming_write(
    method get_miss_handler (line 68) | async fn get_miss_handler(
    method purge (line 78) | async fn purge(
    method update_meta (line 86) | async fn update_meta(
    method support_streaming_partial_write (line 96) | fn support_streaming_partial_write(&self) -> bool {
    method as_any (line 101) | fn as_any(&self) -> &(dyn Any + Send + Sync + 'static);
  type HandleHit (line 106) | pub trait HandleHit {
    method read_body (line 110) | async fn read_body(&mut self) -> Result<Option<bytes::Bytes>>;
    method finish (line 113) | async fn finish(
    method can_seek (line 121) | fn can_seek(&self) -> bool {
    method can_seek_multipart (line 128) | fn can_seek_multipart(&self) -> bool {
    method seek (line 135) | fn seek(&mut self, _start: usize, _end: Option<usize>) -> Result<()> {
    method seek_multipart (line 148) | fn seek_multipart(&mut self, start: usize, end: Option<usize>) -> Resu...
    method should_count_access (line 159) | fn should_count_access(&self) -> bool {
    method get_eviction_weight (line 169) | fn get_eviction_weight(&self) -> usize {
    method as_any (line 174) | fn as_any(&self) -> &(dyn Any + Send + Sync);
    method as_any_mut (line 177) | fn as_any_mut(&mut self) -> &mut (dyn Any + Send + Sync);
  type HitHandler (line 181) | pub type HitHandler = Box<dyn HandleHit + Sync + Send>;
  type MissFinishType (line 184) | pub enum MissFinishType {
  type HandleMiss (line 193) | pub trait HandleMiss {
    method write_body (line 195) | async fn write_body(&mut self, data: bytes::Bytes, eof: bool) -> Resul...
    method finish (line 201) | async fn finish(
    method streaming_write_tag (line 217) | fn streaming_write_tag(&self) -> Option<&[u8]> {
  type MissHandler (line 223) | pub type MissHandler = Box<dyn HandleMiss + Sync + Send>;
  type U64WriteId (line 231) | pub struct U64WriteId([u8; 8]);
    method as_bytes (line 234) | pub fn as_bytes(&self) -> &[u8] {
    method from (line 240) | fn from(value: u64) -> U64WriteId {
    type Error (line 250) | type Error = std::array::TryFromSliceError;
    method try_from (line 252) | fn try_from(value: &[u8]) -> std::result::Result<Self, Self::Error> {
  function from (line 245) | fn from(value: U64WriteId) -> u64 {
  type U32WriteId (line 262) | pub struct U32WriteId([u8; 4]);
    method as_bytes (line 265) | pub fn as_bytes(&self) -> &[u8] {
    method from (line 271) | fn from(value: u32) -> U32WriteId {
    type Error (line 281) | type Error = std::array::TryFromSliceError;
    method try_from (line 283) | fn try_from(value: &[u8]) -> std::result::Result<Self, Self::Error> {
  function from (line 276) | fn from(value: U32WriteId) -> u32 {

FILE: pingora-cache/src/trace.rs
  type Span (line 24) | pub type Span = cf_rustracing::span::Span<SpanContextState>;
  type SpanHandle (line 25) | pub type SpanHandle = cf_rustracing::span::SpanHandle<SpanContextState>;
  type CacheTraceCTX (line 28) | pub(crate) struct CacheTraceCTX {
    method new (line 59) | pub fn new() -> Self {
    method enable (line 67) | pub fn enable(&mut self, cache_span: Span) {
    method get_cache_span (line 71) | pub fn get_cache_span(&self) -> SpanHandle {
    method child (line 76) | pub fn child(&self, name: &'static str) -> Span {
    method start_miss_span (line 80) | pub fn start_miss_span(&mut self) {
    method get_miss_span (line 84) | pub fn get_miss_span(&self) -> SpanHandle {
    method finish_miss_span (line 88) | pub fn finish_miss_span(&mut self) {
    method start_hit_span (line 92) | pub fn start_hit_span(&mut self, phase: CachePhase, hit_status: HitSta...
    method get_hit_span (line 99) | pub fn get_hit_span(&self) -> SpanHandle {
    method finish_hit_span (line 103) | pub fn finish_hit_span(&mut self) {
    method log_meta_in_hit_span (line 107) | pub fn log_meta_in_hit_span(&mut self, meta: &CacheMeta) {
    method log_meta_in_miss_span (line 111) | pub fn log_meta_in_miss_span(&mut self, meta: &CacheMeta) {
  function tag_span_with_meta (line 36) | pub fn tag_span_with_meta(span: &mut Span, meta: &CacheMeta) {

FILE: pingora-cache/src/variance.rs
  type VarianceBuilder (line 10) | pub struct VarianceBuilder<'a> {
  function new (line 17) | pub fn new() -> Self {
  function add_value (line 25) | pub fn add_value(&mut self, name: &'a str, value: &'a (impl AsRef<[u8]> ...
  function add_owned_value (line 34) | pub fn add_owned_value(&mut self, name: &'a str, value: Vec<u8>) {
  function has_variance (line 39) | pub fn has_variance(&self) -> bool {
  function finalize (line 44) | pub fn finalize(self) -> Option<HashBinary> {
  function test_basic (line 66) | fn test_basic() {
  function test_value_ordering (line 84) | fn test_value_ordering() {
  function test_value_overriding (line 108) | fn test_value_overriding() {

FILE: pingora-core/examples/bootstrap_as_a_service.rs
  type MyService (line 53) | pub struct MyService;
  method start_service (line 57) | async fn start_service(
  method name (line 71) | fn name(&self) -> &str {
  method threads (line 75) | fn threads(&self) -> Option<usize> {
  function main (line 80) | fn main() {

FILE: pingora-core/examples/client_cert.rs
  type MyTlsInfo (line 42) | struct MyTlsInfo {
  type MyApp (line 51) | struct MyApp;
  method response (line 55) | async fn response(&self, session: &mut ServerSession) -> http::Response<...
  type MyTlsCallbacks (line 89) | struct MyTlsCallbacks;
  method handshake_complete_callback (line 94) | async fn handshake_complete_callback(
  function san_to_string (line 132) | fn san_to_string(san: &GeneralName) -> Option<String> {
  function bytes_to_ip_addr (line 149) | fn bytes_to_ip_addr(bytes: &[u8]) -> Option<IpAddr> {
  function main (line 189) | fn main() -> Result<(), Box<dyn std::error::Error>> {
  function main (line 225) | fn main() {

FILE: pingora-core/examples/service_dependencies.rs
  type DatabaseService (line 57) | pub struct DatabaseService {
    method new (line 62) | fn new() -> Self {
    method get_connection_string (line 68) | fn get_connection_string(&self) -> Arc<Mutex<Option<String>>> {
  method start_service (line 75) | async fn start_service(
  method name (line 103) | fn name(&self) -> &str {
  method threads (line 107) | fn threads(&self) -> Option<usize> {
  type CacheService (line 114) | pub struct CacheService;
  method start_service (line 120) | async fn start_service(
  method name (line 137) | fn name(&self) -> &str {
  method threads (line 141) | fn threads(&self) -> Option<usize> {
  type ApiService (line 148) | pub struct ApiService {
    method new (line 153) | fn new(db_connection: Arc<Mutex<Option<String>>>) -> Self {
  method start_service (line 162) | async fn start_service(
  method name (line 187) | fn name(&self) -> &str {
  method threads (line 191) | fn threads(&self) -> Option<usize> {
  function main (line 196) | fn main() {

FILE: pingora-core/src/apps/http_app.rs
  type ServeHttp (line 32) | pub trait ServeHttp {
    method response (line 41) | async fn response(&self, http_session: &mut ServerSession) -> Response...
  method process_new_http (line 50) | async fn process_new_http(
  type HttpServer (line 112) | pub struct HttpServer<SV> {
  function new_app (line 121) | pub fn new_app(app: SV) -> Self {
  function add_module (line 131) | pub fn add_module(&mut self, module: ModuleBuilder) {
  method process_new_http (line 141) | async fn process_new_http(
  method h2_options (line 218) | fn h2_options(&self) -> Option<H2Options> {
  method server_options (line 222) | fn server_options(&self) -> Option<&HttpServerOptions> {

FILE: pingora-core/src/apps/mod.rs
  constant H2_PREFACE (line 33) | const H2_PREFACE: &[u8] = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";
  type ServerApp (line 37) | pub trait ServerApp {
    method process_new (line 50) | async fn process_new(
    method cleanup (line 58) | async fn cleanup(&self) {}
    method process_new (line 185) | async fn process_new(
    method cleanup (line 294) | async fn cleanup(&self) {
  type HttpServerOptions (line 63) | pub struct HttpServerOptions {
  type HttpPersistentSettings (line 88) | pub struct HttpPersistentSettings {
    method for_session (line 94) | pub fn for_session(session: &ServerSession) -> Self {
    method apply_to_session (line 101) | pub fn apply_to_session(self, session: &mut ServerSession) {
  type ReusedHttpStream (line 119) | pub struct ReusedHttpStream {
    method new (line 125) | pub fn new(stream: Stream, persistent_settings: Option<HttpPersistentS...
    method consume (line 132) | pub fn consume(self) -> (Stream, Option<HttpPersistentSettings>) {
  type HttpServerApp (line 139) | pub trait HttpServerApp {
    method process_new_http (line 145) | async fn process_new_http(
    method h2_options (line 156) | fn h2_options(&self) -> Option<server::H2Options> {
    method server_options (line 164) | fn server_options(&self) -> Option<&HttpServerOptions> {
    method http_cleanup (line 168) | async fn http_cleanup(&self) {}
    method process_custom_session (line 171) | async fn process_custom_session(

FILE: pingora-core/src/apps/prometheus_http_app.rs
  type PrometheusHttpApp (line 30) | pub struct PrometheusHttpApp;
  method response (line 34) | async fn response(&self, _http_session: &mut ServerSession) -> Response<...
  type PrometheusServer (line 51) | pub type PrometheusServer = HttpServer<PrometheusHttpApp>;
    method new (line 54) | pub fn new() -> Self {

FILE: pingora-core/src/connectors/http/custom/mod.rs
  type Connection (line 26) | pub enum Connection<S: Session> {
  type Connector (line 32) | pub trait Connector: Send + Sync + Unpin + 'static {
    method get_http_session (line 35) | async fn get_http_session<P: Peer + Send + Sync + 'static>(
    method reused_http_session (line 40) | async fn reused_http_session<P: Peer + Send + Sync + 'static>(
    method release_http_session (line 45) | async fn release_http_session<P: Peer + Send + Sync + 'static>(
    type Session (line 56) | type Session = ();
    method get_http_session (line 58) | async fn get_http_session<P: Peer + Send + Sync + 'static>(
    method reused_http_session (line 65) | async fn reused_http_session<P: Peer + Send + Sync + 'static>(
    method release_http_session (line 72) | async fn release_http_session<P: Peer + Send + Sync + 'static>(

FILE: pingora-core/src/connectors/http/mod.rs
  type Connector (line 30) | pub struct Connector<C = ()>
  function new (line 40) | pub fn new(options: Option<ConnectorOptions>) -> Self {
  function new_custom (line 53) | pub fn new_custom(options: Option<ConnectorOptions>, custom: C) -> Self {
  function get_http_session (line 64) | pub async fn get_http_session<P: Peer + Send + Sync + 'static>(
  function release_http_session (line 133) | pub async fn release_http_session<P: Peer + Send + Sync + 'static>(
  function prefer_h1 (line 151) | pub fn prefer_h1(&self, peer: &impl Peer) {
  function get_http (line 176) | async fn get_http(http: &mut Http1Session, expected_status: u16) {
  function test_connect_h2 (line 188) | async fn test_connect_h2() {
  function test_connect_h1 (line 213) | async fn test_connect_h1() {
  function test_connect_h2_fallback_h1_reuse (line 239) | async fn test_connect_h2_fallback_h1_reuse() {
  function test_connect_prefer_h1 (line 274) | async fn test_connect_prefer_h1() {
  type MockConnector (line 302) | struct MockConnector {
    type Session (line 309) | type Session = ();
    method get_http_session (line 311) | async fn get_http_session<P: Peer + Send + Sync + 'static>(
    method reused_http_session (line 323) | async fn reused_http_session<P: Peer + Send + Sync + 'static>(
    method release_http_session (line 336) | async fn release_http_session<P: Peer + Send + Sync + 'static>(
  function get_available_port (line 348) | async fn get_available_port() -> u16 {
  function create_test_connector (line 358) | fn create_test_connector() -> Connector<MockConnector> {
  function create_peer_with_custom_proto (line 377) | fn create_peer_with_custom_proto(port: u16, proto: &[u8]) -> HttpPeer {
  function build_custom_tls_listener (line 387) | async fn build_custom_tls_listener(port: u16, custom_alpn: CustomALPN) -...
  function spawn_test_tls_server (line 408) | fn spawn_test_tls_server(listener: TransportStack) -> JoinHandle<()> {
  function test_custom_client_custom_upstream (line 424) | async fn test_custom_client_custom_upstream() {
  function test_incompatible_custom_client_custom_upstream (line 482) | async fn test_incompatible_custom_client_custom_upstream() {
  function test_custom_client_non_custom_upstream (line 519) | async fn test_custom_client_non_custom_upstream() {
  type NoCertificateVerification (line 566) | pub struct NoCertificateVerification;
  method verify_server_cert (line 569) | fn verify_server_cert(
  method verify_tls12_signature (line 580) | fn verify_tls12_signature(
  method verify_tls13_signature (line 589) | fn verify_tls13_signature(
  method supported_verify_schemes (line 598) | fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
  function apply_no_verify (line 603) | pub fn apply_no_verify(config: &mut rustls::ClientConfig) {

FILE: pingora-core/src/connectors/http/v1.rs
  type Connector (line 22) | pub struct Connector {
    method new (line 27) | pub fn new(options: Option<ConnectorOptions>) -> Self {
    method get_http_session (line 33) | pub async fn get_http_session<P: Peer + Send + Sync + 'static>(
    method reused_http_session (line 42) | pub async fn reused_http_session<P: Peer + Send + Sync + 'static>(
    method release_http_session (line 51) | pub async fn release_http_session<P: Peer + Send + Sync + 'static>(
  function get_http (line 74) | async fn get_http(http: &mut HttpSession, expected_status: u16) {
  function test_connect (line 86) | async fn test_connect() {
  function test_reuse_rejects_fd_mismatch (line 108) | async fn test_reuse_rejects_fd_mismatch() {
  function test_connect_tls (line 165) | async fn test_connect_tls() {

FILE: pingora-core/src/connectors/http/v2.rs
  type Stub (line 35) | struct Stub(SendRequest<Bytes>);
    method new_stream (line 38) | async fn new_stream(&self) -> Result<SendRequest<Bytes>> {
  type ConnectionRefInner (line 47) | pub(crate) struct ConnectionRefInner {
  type ConnectionRef (line 66) | pub struct ConnectionRef(Arc<ConnectionRefInner>);
    method new (line 69) | pub fn new(
    method more_streams_allowed (line 90) | pub fn more_streams_allowed(&self) -> bool {
    method is_idle (line 97) | pub fn is_idle(&self) -> bool {
    method release_stream (line 101) | pub fn release_stream(&self) {
    method id (line 105) | pub fn id(&self) -> UniqueIDType {
    method digest (line 109) | pub fn digest(&self) -> &Digest {
    method digest_mut (line 113) | pub fn digest_mut(&mut self) -> Option<&mut Digest> {
    method ping_timedout (line 117) | pub fn ping_timedout(&self) -> bool {
    method is_closed (line 121) | pub fn is_closed(&self) -> bool {
    method is_shutting_down (line 127) | pub fn is_shutting_down(&self) -> bool {
    method spawn_stream (line 132) | pub async fn spawn_stream(&self) -> Result<Option<Http2Session>> {
  type InUsePool (line 166) | pub struct InUsePool {
    method new (line 172) | fn new() -> Self {
    method try_remove_empty_node (line 184) | fn try_remove_empty_node(&self, reuse_hash: u64) {
    method insert (line 193) | pub fn insert(&self, reuse_hash: u64, conn: ConnectionRef) {
    method get (line 217) | pub fn get(&self, reuse_hash: u64) -> Option<ConnectionRef> {
    method release (line 238) | pub fn release(&self, reuse_hash: u64, id: UniqueIDType) -> Option<Con...
  constant DEFAULT_POOL_SIZE (line 257) | const DEFAULT_POOL_SIZE: usize = 128;
  type Connector (line 260) | pub struct Connector {
    method new (line 271) | pub fn new(options: Option<ConnectorOptions>) -> Self {
    method transport (line 283) | pub fn transport(&self) -> &TransportConnector {
    method idle_pool (line 287) | pub fn idle_pool(&self) -> &Arc<ConnectionPool<ConnectionRef>> {
    method in_use_pool (line 291) | pub fn in_use_pool(&self) -> &InUsePool {
    method new_http_session (line 298) | pub async fn new_http_session<P: Peer + Send + Sync + 'static, C: Sess...
    method reused_http_session (line 344) | pub async fn reused_http_session<P: Peer + Send + Sync + 'static>(
    method release_http_session (line 404) | pub fn release_http_session<P: Peer + Send + Sync + 'static>(
    method prefer_h1 (line 450) | pub fn prefer_h1(&self, peer: &impl Peer) {
    method h1_is_preferred (line 454) | pub(crate) fn h1_is_preferred(&self, peer: &impl Peer) -> bool {
  constant H2_WINDOW_SIZE (line 468) | const H2_WINDOW_SIZE: u32 = 1 << 23;
  function handshake (line 470) | pub async fn handshake(
  function test_connect_h2 (line 547) | async fn test_connect_h2() {
  function test_connect_h1 (line 564) | async fn test_connect_h1() {
  function test_connect_h1_plaintext (line 581) | async fn test_connect_h1_plaintext() {
  function test_h2_single_stream (line 598) | async fn test_h2_single_stream() {
  function test_h2_multiple_stream (line 634) | async fn test_h2_multiple_stream() {
  function test_h2_reuse_rejects_fd_mismatch (line 679) | async fn test_h2_reuse_rejects_fd_mismatch() {

FILE: pingora-core/src/connectors/l4.rs
  type Connect (line 36) | pub trait Connect: std::fmt::Debug {
    method connect (line 37) | async fn connect(&self, addr: &SocketAddr) -> Result<Stream>;
  type BindTo (line 42) | pub struct BindTo {
    method set_port_range (line 57) | pub fn set_port_range(&mut self, range: Option<(u16, u16)>) -> Result<...
    method set_fallback (line 76) | pub fn set_fallback(&mut self, fallback: bool) {
    method port_range (line 81) | pub fn port_range(&self) -> Option<(u16, u16)> {
    method will_fallback (line 86) | pub fn will_fallback(&self) -> bool {
  function connect (line 92) | pub(crate) async fn connect<P>(peer: &P, bind_to: Option<BindTo>) -> Res...
  function bind_to_random (line 213) | pub(crate) fn bind_to_random<P: Peer>(
  function proxy_connect (line 261) | async fn proxy_connect<P: Peer>(peer: &P) -> Result<Stream> {
  function proxy_connect (line 302) | async fn proxy_connect<P: Peer>(peer: &P) -> Result<Stream> {
  function wait_for_peer (line 325) | async fn wait_for_peer<P>(peer: &P)
  function test_conn_error_refused (line 347) | async fn test_conn_error_refused() {
  function test_conn_error_no_route (line 356) | async fn test_conn_error_no_route() {
  function test_conn_error_addr_not_avail (line 363) | async fn test_conn_error_addr_not_avail() {
  function test_conn_error_other (line 375) | async fn test_conn_error_other() {
  function test_conn_timeout (line 396) | async fn test_conn_timeout() {
  function test_tweak_hook (line 405) | async fn test_tweak_hook() {
  function test_custom_connect (line 425) | async fn test_custom_connect() {
  function test_connect_proxy_fail (line 449) | async fn test_connect_proxy_fail() {
  function test_connect_proxy_work (line 467) | async fn test_connect_proxy_work() {
  function test_connect_proxy_conn_closed (line 496) | async fn test_connect_proxy_conn_closed() {
  function test_bind_to_port_range_on_connect (line 527) | async fn test_bind_to_port_range_on_connect() {
  function test_bind_to_port_ranges (line 627) | fn test_bind_to_port_ranges() {

FILE: pingora-core/src/connectors/mod.rs
  type ConnectorOptions (line 46) | pub struct ConnectorOptions {
    method from_server_conf (line 86) | pub fn from_server_conf(server_conf: &ServerConf) -> Self {
    method new (line 126) | pub fn new(keepalive_pool_size: usize) -> Self {
  type TransportConnector (line 142) | pub struct TransportConnector {
    method new (line 155) | pub fn new(mut options: Option<ConnectorOptions>) -> Self {
    method new_stream (line 181) | pub async fn new_stream<P: Peer + Send + Sync + 'static>(&self, peer: ...
    method reused_stream (line 202) | pub async fn reused_stream<P: Peer + Send + Sync>(&self, peer: &P) -> ...
    method release_stream (line 258) | pub fn release_stream(
    method get_stream (line 287) | pub async fn get_stream<P: Peer + Send + Sync + 'static>(
    method prefer_h1 (line 301) | pub fn prefer_h1(&self, peer: &impl Peer) {
  constant DEFAULT_POOL_SIZE (line 151) | const DEFAULT_POOL_SIZE: usize = 128;
  function do_connect (line 308) | async fn do_connect<P: Peer + Send + Sync>(
  function do_connect_inner (line 331) | async fn do_connect_inner<P: Peer + Send + Sync>(
  type PreferredHttpVersion (line 346) | struct PreferredHttpVersion {
    method new (line 354) | pub fn new() -> Self {
    method add (line 360) | pub fn add(&self, peer: &impl Peer, version: u8) {
    method get (line 366) | pub fn get(&self, peer: &impl Peer) -> Option<ALPN> {
  function test_reusable_stream (line 379) | fn test_reusable_stream(stream: &mut Stream) -> bool {
  function unique_uds_path (line 409) | pub fn unique_uds_path(test_name: &str) -> String {
  function spawn_mock_uds_server (line 423) | pub fn spawn_mock_uds_server(
  function spawn_mock_uds_server_close_immediate (line 454) | pub fn spawn_mock_uds_server_close_immediate(
  constant BLACK_HOLE (line 492) | const BLACK_HOLE: &str = "192.0.2.1:79";
  function test_connect (line 495) | async fn test_connect() {
  function test_connect_tls (line 507) | async fn test_connect_tls() {
  function test_connect_uds (line 522) | async fn test_connect_uds() {
  function do_test_conn_timeout (line 550) | async fn do_test_conn_timeout(conf: Option<ConnectorOptions>) {
  function test_conn_timeout (line 562) | async fn test_conn_timeout() {
  function test_conn_timeout_with_offload (line 567) | async fn test_conn_timeout_with_offload() {
  function test_connector_bind_to (line 574) | async fn test_connector_bind_to() {
  function get_do_connect_failure_with_peer (line 590) | async fn get_do_connect_failure_with_peer(peer: &BasicPeer) -> (ErrorTyp...
  function test_do_connect_with_total_timeout (line 606) | async fn test_do_connect_with_total_timeout() {
  function test_tls_connect_timeout_supersedes_total (line 615) | async fn test_tls_connect_timeout_supersedes_total() {
  function test_do_connect_without_total_timeout (line 625) | async fn test_do_connect_without_total_timeout() {

FILE: pingora-core/src/connectors/offload.rs
  type OffloadRuntime (line 23) | pub(crate) struct OffloadRuntime {
    method new (line 32) | pub fn new(shards: usize, thread_per_shard: usize) -> Self {
    method init_pools (line 42) | fn init_pools(&self) -> Box<[(Handle, Sender<()>)]> {
    method get_runtime (line 66) | pub fn get_runtime(&self, hash: u64) -> &Handle {

FILE: pingora-core/src/connectors/tls/boringssl_openssl/mod.rs
  type TlsConnector (line 35) | pub type TlsConnector = SslConnector;
  constant CIPHER_LIST (line 37) | const CIPHER_LIST: &str = "AES-128-GCM-SHA256\
  constant SIGALG_LIST (line 56) | const SIGALG_LIST: &str = "ECDSA_SECP256R1_SHA256\
  constant BORINGSSL_CURVE_LIST (line 75) | const BORINGSSL_CURVE_LIST: &[SslCurve] = &[
  function init_ssl_cert_env_vars (line 83) | fn init_ssl_cert_env_vars() {
  type Connector (line 92) | pub struct Connector {
    method new (line 97) | pub fn new(options: Option<ConnectorOptions>) -> Self {
  function connect (line 153) | pub(crate) async fn connect<T, P>(

FILE: pingora-core/src/connectors/tls/mod.rs
  function replace_leftmost_underscore (line 45) | pub fn replace_leftmost_underscore(sni: &str) -> Option<String> {
  function test_replace_leftmost_underscore (line 65) | fn test_replace_leftmost_underscore() {

FILE: pingora-core/src/connectors/tls/rustls/mod.rs
  type Connector (line 41) | pub struct Connector {
    method new (line 49) | pub fn new(config_opt: Option<ConnectorOptions>) -> Self {
  type TlsConnector (line 54) | pub struct TlsConnector {
    method build_connector (line 60) | pub(crate) fn build_connector(options: Option<ConnectorOptions>) -> Re...
  function connect (line 126) | pub async fn connect<T, P>(
  type VerificationMode (line 265) | pub enum VerificationMode {
  type CustomServerCertVerifier (line 274) | pub struct CustomServerCertVerifier {
    method new (line 280) | pub fn new(delegate: Arc<WebPkiServerVerifier>, verification_mode: Ver...
  method verify_server_cert (line 293) | fn verify_server_cert(
  method verify_tls12_signature (line 332) | fn verify_tls12_signature(
  method verify_tls13_signature (line 341) | fn verify_tls13_signature(
  method supported_verify_schemes (line 350) | fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {

FILE: pingora-core/src/connectors/tls/s2n/mod.rs
  constant DEFAULT_CONFIG_CACHE_SIZE (line 40) | const DEFAULT_CONFIG_CACHE_SIZE: NonZero<usize> = NonZero::new(10).unwra...
  type Connector (line 43) | pub struct Connector {
    method new (line 51) | pub fn new(options: Option<ConnectorOptions>) -> Self {
  type TlsConnector (line 67) | pub struct TlsConnector {
    method new (line 73) | pub fn new(options: Option<ConnectorOptions>) -> Self {
    method load_config (line 82) | fn load_config(&self, config_options: S2NConfigOptions) -> Result<Conf...
    method load_config_from_cache (line 97) | fn load_config_from_cache(&self, config_hash: u64) -> Option<Config> {
    method put_config_in_cache (line 106) | fn put_config_in_cache(&self, config_hash: u64, config: Config) {
    method create_config_cache (line 113) | fn create_config_cache(
  function connect (line 130) | pub(crate) async fn connect<T, P>(
  function create_s2n_config (line 173) | fn create_s2n_config(
  type S2NConfigOptions (line 252) | struct S2NConfigOptions {
    method from_peer (line 263) | fn from_peer<P>(peer: &P, alpn_override: Option<ALPN>) -> Self
    method config_hash (line 278) | fn config_hash(&self) -> u64 {
  method hash (line 286) | fn hash<H: Hasher>(&self, state: &mut H) {
  constant CA_CERT_FILE (line 307) | const CA_CERT_FILE: &str = "tests/certs/ca.crt";
  constant ALT_CA_CERT_FILE (line 308) | const ALT_CA_CERT_FILE: &str = "tests/certs/alt-ca.crt";
  constant CERT_FILE (line 310) | const CERT_FILE: &str = "tests/certs/server.crt";
  constant ALT_CERT_FILE (line 311) | const ALT_CERT_FILE: &str = "tests/certs/alt-server.crt";
  constant KEY_FILE (line 313) | const KEY_FILE: &str = "tests/certs/server.key";
  function read_file (line 315) | fn read_file(file: &str) -> Vec<u8> {
  function load_pem_from_file (line 319) | fn load_pem_from_file(file: &str) -> X509Pem {
  function create_config_options (line 323) | fn create_config_options() -> S2NConfigOptions {
  function config_cache_hit_identical (line 339) | fn config_cache_hit_identical() {
  function config_cache_miss_max_blinding_delay_changed (line 351) | fn config_cache_miss_max_blinding_delay_changed() {
  function config_cache_miss_alpn_changed (line 363) | fn config_cache_miss_alpn_changed() {
  function config_cache_miss_verify_cert_changed (line 375) | fn config_cache_miss_verify_cert_changed() {
  function config_cache_miss_verify_hostname_changed (line 387) | fn config_cache_miss_verify_hostname_changed() {
  function config_cache_miss_use_system_certs_changed (line 399) | fn config_cache_miss_use_system_certs_changed() {
  function config_cache_miss_ca_changed (line 411) | fn config_cache_miss_ca_changed() {
  function config_cache_miss_client_cert_key_changed (line 423) | fn config_cache_miss_client_cert_key_changed() {

FILE: pingora-core/src/listeners/connection_filter.rs
  type ConnectionFilter (line 66) | pub trait ConnectionFilter: Debug + Send + Sync {
    method should_accept (line 92) | async fn should_accept(&self, _addr: Option<&SocketAddr>) -> bool {
    method should_accept (line 121) | async fn should_accept(&self, addr_opt: Option<&SocketAddr>) -> bool {
  type AcceptAllFilter (line 102) | pub struct AcceptAllFilter;
  type BlockListFilter (line 115) | struct BlockListFilter {
  function test_accept_all_filter (line 129) | async fn test_accept_all_filter() {
  function test_blocklist_filter (line 136) | async fn test_blocklist_filter() {

FILE: pingora-core/src/listeners/l4.rs
  constant TCP_LISTENER_MAX_TRY (line 48) | const TCP_LISTENER_MAX_TRY: usize = 30;
  constant TCP_LISTENER_TRY_STEP (line 49) | const TCP_LISTENER_TRY_STEP: Duration = Duration::from_secs(1);
  constant LISTENER_BACKLOG (line 51) | const LISTENER_BACKLOG: u32 = 65535;
  type ServerAddress (line 55) | pub enum ServerAddress {
    method as_ref (line 62) | fn as_ref(&self) -> &str {
    method tcp_sock_opts (line 72) | fn tcp_sock_opts(&self) -> Option<&TcpSocketOptions> {
  type TcpSocketOptions (line 84) | pub struct TcpSocketOptions {
  function set_perms (line 125) | pub(super) fn set_perms(path: &str, perms: Option<Permissions>) -> Resul...
  function set_backlog (line 133) | pub(super) fn set_backlog(l: StdUnixListener, backlog: u32) -> Result<Un...
  function bind (line 143) | pub(super) fn bind(addr: &str, perms: Option<Permissions>) -> Result<Lis...
  function apply_tcp_socket_options (line 169) | fn apply_tcp_socket_options(sock: &TcpSocket, opt: Option<&TcpSocketOpti...
  function from_raw_fd (line 204) | fn from_raw_fd(address: &ServerAddress, fd: i32) -> Result<Listener> {
  function bind_tcp (line 229) | async fn bind_tcp(addr: &str, opt: Option<TcpSocketOptions>) -> Result<L...
  function bind (line 277) | async fn bind(addr: &ServerAddress) -> Result<Listener> {
  type ListenerEndpoint (line 286) | pub struct ListenerEndpoint {
    method builder (line 381) | pub fn builder() -> ListenerEndpointBuilder {
    method as_str (line 385) | pub fn as_str(&self) -> &str {
    method apply_stream_settings (line 389) | fn apply_stream_settings(&self, stream: &mut Stream) -> Result<()> {
    method accept (line 419) | pub async fn accept(&self) -> Result<Stream> {
  type ListenerEndpointBuilder (line 294) | pub struct ListenerEndpointBuilder {
    method new (line 301) | pub fn new() -> ListenerEndpointBuilder {
    method listen_addr (line 309) | pub fn listen_addr(&mut self, addr: ServerAddress) -> &mut Self {
    method connection_filter (line 315) | pub fn connection_filter(&mut self, filter: Arc<dyn ConnectionFilter>)...
    method listen (line 321) | pub async fn listen(self, fds: Option<ListenFds>) -> Result<ListenerEn...
    method listen (line 359) | pub async fn listen(self) -> Result<ListenerEndpoint> {
  function test_listen_tcp (line 472) | async fn test_listen_tcp() {
  function test_listen_tcp_ipv6_only (line 495) | async fn test_listen_tcp_ipv6_only() {
  function test_listen_uds (line 526) | async fn test_listen_uds() {
  function test_tcp_so_reuseport (line 546) | async fn test_tcp_so_reuseport() {
  function test_tcp_so_reuseport_false (line 570) | async fn test_tcp_so_reuseport_false() {
  function test_connection_filter_accept (line 606) | async fn test_connection_filter_accept() {
  function test_connection_filter_blocks_all (line 669) | async fn test_connection_filter_blocks_all() {

FILE: pingora-core/src/listeners/mod.rs
  type AcceptAllFilter (line 56) | pub struct AcceptAllFilter;
  type ConnectionFilter (line 59) | pub trait ConnectionFilter: std::fmt::Debug + Send + Sync {
    method should_accept (line 60) | fn should_accept(&self, _addr: &std::net::SocketAddr) -> bool {
    method should_accept (line 67) | fn should_accept(&self, _addr: &std::net::SocketAddr) -> bool {
  type TlsAccept (line 95) | pub trait TlsAccept {
    method certificate_callback (line 101) | async fn certificate_callback(&self, _ssl: &mut TlsRef) -> () {
    method handshake_complete_callback (line 111) | async fn handshake_complete_callback(
  type TlsAcceptCallbacks (line 119) | pub type TlsAcceptCallbacks = Box<dyn TlsAccept + Send + Sync>;
  type TransportStackBuilder (line 121) | struct TransportStackBuilder {
    method build (line 129) | pub async fn build(
  type TransportStack (line 156) | pub(crate) struct TransportStack {
    method as_str (line 162) | pub fn as_str(&self) -> &str {
    method accept (line 166) | pub async fn accept(&self) -> Result<UninitializedStream> {
    method cleanup (line 174) | pub fn cleanup(&mut self) {
  type UninitializedStream (line 179) | pub(crate) struct UninitializedStream {
    method handshake (line 185) | pub async fn handshake(mut self) -> Result<Stream> {
    method peer_addr (line 196) | pub fn peer_addr(&self) -> Option<SocketAddr> {
  type Listeners (line 204) | pub struct Listeners {
    method new (line 212) | pub fn new() -> Self {
    method tcp (line 220) | pub fn tcp(addr: &str) -> Self {
    method uds (line 228) | pub fn uds(addr: &str, perm: Option<Permissions>) -> Self {
    method tls (line 238) | pub fn tls(addr: &str, cert_path: &str, key_path: &str) -> Result<Self> {
    method add_tcp (line 245) | pub fn add_tcp(&mut self, addr: &str) {
    method add_tcp_with_settings (line 250) | pub fn add_tcp_with_settings(&mut self, addr: &str, sock_opt: TcpSocke...
    method add_uds (line 256) | pub fn add_uds(&mut self, addr: &str, perm: Option<Permissions>) {
    method add_tls (line 262) | pub fn add_tls(&mut self, addr: &str, cert_path: &str, key_path: &str)...
    method add_tls_with_settings (line 269) | pub fn add_tls_with_settings(
    method add_address (line 279) | pub fn add_address(&mut self, addr: ServerAddress) {
    method set_connection_filter (line 285) | pub fn set_connection_filter(&mut self, filter: Arc<dyn ConnectionFilt...
    method add_endpoint (line 298) | pub fn add_endpoint(&mut self, l4: ServerAddress, tls: Option<TlsSetti...
    method build (line 307) | pub(crate) async fn build(
    method cleanup (line 327) | pub(crate) fn cleanup(&self) {
  function test_listen_tcp (line 343) | async fn test_listen_tcp() {
  function test_listen_tls (line 375) | async fn test_listen_tls() {
  function test_connection_filter_inheritance (line 417) | fn test_connection_filter_inheritance() {

FILE: pingora-core/src/listeners/tls/boringssl_openssl/mod.rs
  constant TLS_CONF_ERR (line 31) | pub const TLS_CONF_ERR: ErrorType = ErrorType::Custom("TLSConfigError");
  type Acceptor (line 33) | pub(crate) struct Acceptor {
    method tls_handshake (line 141) | pub async fn tls_handshake<S: IO>(&self, stream: S) -> Result<SslStrea...
  type TlsSettings (line 39) | pub struct TlsSettings {
    method from (line 45) | fn from(settings: SslAcceptorBuilder) -> Self {
    method intermediate (line 71) | pub fn intermediate(cert_path: &str, key_path: &str) -> Result<Self> {
    method with_callbacks (line 92) | pub fn with_callbacks(callbacks: TlsAcceptCallbacks) -> Result<Self> {
    method enable_h2 (line 105) | pub fn enable_h2(&mut self) {
    method set_alpn (line 110) | pub fn set_alpn(&mut self, alpn: ALPN) {
    method build (line 132) | pub(crate) fn build(self) -> Acceptor {
  type Target (line 54) | type Target = SslAcceptorBuilder;
  method deref (line 56) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 62) | fn deref_mut(&mut self) -> &mut Self::Target {
  function valid_alpn (line 156) | pub(super) fn valid_alpn(alpn_in: &[u8]) -> bool {
  function select_protocol (line 169) | pub(super) fn select_protocol<'a>(
  function prefer_h2 (line 187) | pub fn prefer_h2<'a>(_ssl: &mut SslRef, alpn_in: &'a [u8]) -> Result<&'a...
  function h1_only (line 197) | pub fn h1_only<'a>(_ssl: &mut SslRef, alpn_in: &'a [u8]) -> Result<&'a [...
  function h2_only (line 207) | pub fn h2_only<'a>(_ssl: &mut SslRef, alpn_in: &'a [u8]) -> Result<&'a [...

FILE: pingora-core/src/listeners/tls/rustls/mod.rs
  type TlsSettings (line 30) | pub struct TlsSettings {
    method build (line 50) | pub fn build(self) -> Acceptor {
    method enable_h2 (line 85) | pub fn enable_h2(&mut self) {
    method set_alpn (line 89) | pub fn set_alpn(&mut self, alpn: ALPN) {
    method set_client_cert_verifier (line 94) | pub fn set_client_cert_verifier(&mut self, verifier: Arc<dyn ClientCer...
    method intermediate (line 98) | pub fn intermediate(cert_path: &str, key_path: &str) -> Result<Self>
    method with_callbacks (line 110) | pub fn with_callbacks() -> Result<Self>
  type Acceptor (line 37) | pub struct Acceptor {
    method tls_handshake (line 123) | pub async fn tls_handshake<S: IO>(&self, stream: S) -> Result<TlsStrea...

FILE: pingora-core/src/listeners/tls/s2n/mod.rs
  type TlsSettings (line 29) | pub struct TlsSettings {
    method build (line 46) | pub fn build(self) -> Acceptor {
    method enable_h2 (line 104) | pub fn enable_h2(&mut self) {
    method set_alpn (line 108) | fn set_alpn(&mut self, alpn: ALPN) {
    method set_ca (line 113) | pub fn set_ca(&mut self, ca: CaType) {
    method set_psk_config (line 119) | pub fn set_psk_config(&mut self, psk_config: PskConfig) {
    method set_policy (line 126) | pub fn set_policy(&mut self, policy: S2NPolicy) {
    method set_cert (line 131) | pub fn set_cert(&mut self, cert_path: &str, key_path: &str) {
    method set_client_auth_required (line 137) | pub fn set_client_auth_required(&mut self, required: bool) {
    method set_verify_client_hostname (line 142) | pub fn set_verify_client_hostname(&mut self, verify: bool) {
    method set_max_blinding_delay (line 149) | pub fn set_max_blinding_delay(&mut self, delay: u32) {
    method intermediate (line 153) | pub fn intermediate(cert_path: &str, key_path: &str) -> Result<Self>
    method new (line 170) | pub fn new() -> Self {
  type Acceptor (line 41) | pub struct Acceptor {
    method tls_handshake (line 186) | pub async fn tls_handshake<S: IO>(&self, stream: S) -> Result<TlsStrea...

FILE: pingora-core/src/modules/http/compression.rs
  type ResponseCompression (line 22) | pub struct ResponseCompression(ResponseCompressionCtx);
  type Target (line 25) | type Target = ResponseCompressionCtx;
  method deref (line 27) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 33) | fn deref_mut(&mut self) -> &mut Self::Target {
  method as_any (line 40) | fn as_any(&self) -> &dyn std::any::Any {
  method as_any_mut (line 43) | fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
  method request_header_filter (line 47) | async fn request_header_filter(&mut self, req: &mut RequestHeader) -> Re...
  method response_header_filter (line 52) | async fn response_header_filter(
  method response_body_filter (line 61) | fn response_body_filter(
  method response_done_filter (line 76) | fn response_done_filter(&mut self) -> Result<Option<Bytes>> {
  type ResponseCompressionBuilder (line 87) | pub struct ResponseCompressionBuilder {
    method enable (line 93) | pub fn enable(level: u32) -> ModuleBuilder {
  method init (line 99) | fn init(&self) -> Module {
  method order (line 105) | fn order(&self) -> i16 {

FILE: pingora-core/src/modules/http/grpc_web.rs
  type GrpcWebBridge (line 22) | pub struct GrpcWebBridge(GrpcWebCtx);
  type Target (line 25) | type Target = GrpcWebCtx;
  method deref (line 27) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 33) | fn deref_mut(&mut self) -> &mut Self::Target {
  method as_any (line 40) | fn as_any(&self) -> &dyn std::any::Any {
  method as_any_mut (line 44) | fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
  method request_header_filter (line 48) | async fn request_header_filter(&mut self, req: &mut RequestHeader) -> Re...
  method response_header_filter (line 53) | async fn response_header_filter(
  method response_trailer_filter (line 62) | fn response_trailer_filter(
  type GrpcWeb (line 74) | pub struct GrpcWeb;
  method init (line 77) | fn init(&self) -> Module {

FILE: pingora-core/src/modules/http/mod.rs
  type HttpModule (line 39) | pub trait HttpModule {
    method request_header_filter (line 40) | async fn request_header_filter(&mut self, _req: &mut RequestHeader) ->...
    method request_body_filter (line 44) | async fn request_body_filter(
    method response_header_filter (line 52) | async fn response_header_filter(
    method response_body_filter (line 60) | fn response_body_filter(
    method response_trailer_filter (line 68) | fn response_trailer_filter(
    method response_done_filter (line 75) | fn response_done_filter(&mut self) -> Result<Option<Bytes>> {
    method as_any (line 79) | fn as_any(&self) -> &dyn Any;
    method as_any_mut (line 80) | fn as_any_mut(&mut self) -> &mut dyn Any;
    method as_any (line 292) | fn as_any(&self) -> &dyn Any {
    method as_any_mut (line 295) | fn as_any_mut(&mut self) -> &mut dyn Any {
    method request_header_filter (line 298) | async fn request_header_filter(&mut self, req: &mut RequestHeader) -> ...
    method as_any (line 316) | fn as_any(&self) -> &dyn Any {
    method as_any_mut (line 319) | fn as_any_mut(&mut self) -> &mut dyn Any {
    method request_header_filter (line 322) | async fn request_header_filter(&mut self, req: &mut RequestHeader) -> ...
  type Module (line 83) | pub type Module = Box<dyn HttpModule + 'static + Send + Sync>;
  type HttpModuleBuilder (line 86) | pub trait HttpModuleBuilder {
    method order (line 91) | fn order(&self) -> i16 {
    method init (line 96) | fn init(&self) -> Module;
    method order (line 304) | fn order(&self) -> i16 {
    method init (line 308) | fn init(&self) -> Module {
    method order (line 334) | fn order(&self) -> i16 {
    method init (line 338) | fn init(&self) -> Module {
  type ModuleBuilder (line 99) | pub type ModuleBuilder = Box<dyn HttpModuleBuilder + 'static + Send + Sy...
  type HttpModules (line 102) | pub struct HttpModules {
    method new (line 109) | pub fn new() -> Self {
    method add_module (line 121) | pub fn add_module(&mut self, builder: ModuleBuilder) {
    method build_ctx (line 134) | pub fn build_ctx(&self) -> HttpModuleCtx {
  type HttpModuleCtx (line 161) | pub struct HttpModuleCtx {
    method empty (line 172) | pub fn empty() -> Self {
    method get (line 180) | pub fn get<T: 'static>(&self) -> Option<&T> {
    method get_mut (line 191) | pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
    method request_header_filter (line 202) | pub async fn request_header_filter(&mut self, req: &mut RequestHeader)...
    method request_body_filter (line 210) | pub async fn request_body_filter(
    method response_header_filter (line 222) | pub async fn response_header_filter(
    method response_body_filter (line 234) | pub fn response_body_filter(
    method response_trailer_filter (line 253) | pub fn response_trailer_filter(
    method response_done_filter (line 274) | pub fn response_done_filter(&mut self) -> Result<Option<Bytes>> {
  type MyModule (line 289) | struct MyModule;
  type MyModuleBuilder (line 302) | struct MyModuleBuilder;
  type MyOtherModule (line 313) | struct MyOtherModule;
  type MyOtherModuleBuilder (line 332) | struct MyOtherModuleBuilder;
  function test_module_get (line 344) | fn test_module_get() {
  function test_module_filter (line 358) | async fn test_module_filter() {

FILE: pingora-core/src/protocols/digest.rs
  type Digest (line 29) | pub struct Digest {
  type ProtoDigest (line 41) | pub trait ProtoDigest {
    method get_digest (line 42) | fn get_digest(&self) -> Option<&Digest> {
  type TimingDigest (line 49) | pub struct TimingDigest {
  method default (line 55) | fn default() -> Self {
  type SocketDigest (line 64) | pub struct SocketDigest {
    method from_raw_fd (line 79) | pub fn from_raw_fd(raw_fd: std::os::unix::io::RawFd) -> SocketDigest {
    method from_raw_socket (line 89) | pub fn from_raw_socket(raw_sock: std::os::windows::io::RawSocket) -> S...
    method peer_addr (line 99) | pub fn peer_addr(&self) -> Option<&SocketAddr> {
    method peer_addr (line 106) | pub fn peer_addr(&self) -> Option<&SocketAddr> {
    method local_addr (line 113) | pub fn local_addr(&self) -> Option<&SocketAddr> {
    method local_addr (line 120) | pub fn local_addr(&self) -> Option<&SocketAddr> {
    method is_inet (line 126) | fn is_inet(&self) -> bool {
    method tcp_info (line 131) | pub fn tcp_info(&self) -> Option<TCP_INFO> {
    method tcp_info (line 140) | pub fn tcp_info(&self) -> Option<TCP_INFO> {
    method get_recv_buf (line 149) | pub fn get_recv_buf(&self) -> Option<usize> {
    method get_recv_buf (line 158) | pub fn get_recv_buf(&self) -> Option<usize> {
    method get_snd_buf (line 167) | pub fn get_snd_buf(&self) -> Option<usize> {
    method get_snd_buf (line 176) | pub fn get_snd_buf(&self) -> Option<usize> {
    method original_dst (line 185) | pub fn original_dst(&self) -> Option<&SocketAddr> {
    method original_dst (line 197) | pub fn original_dst(&self) -> Option<&SocketAddr> {
  type GetTimingDigest (line 210) | pub trait GetTimingDigest {
    method get_timing_digest (line 212) | fn get_timing_digest(&self) -> Vec<Option<TimingDigest>>;
    method get_read_pending_time (line 213) | fn get_read_pending_time(&self) -> Duration {
    method get_write_pending_time (line 216) | fn get_write_pending_time(&self) -> Duration {
  type GetProxyDigest (line 222) | pub trait GetProxyDigest {
    method get_proxy_digest (line 223) | fn get_proxy_digest(&self) -> Option<Arc<ProxyDigest>>;
    method set_proxy_digest (line 224) | fn set_proxy_digest(&mut self, _digest: ProxyDigest) {}
  type GetSocketDigest (line 228) | pub trait GetSocketDigest {
    method get_socket_digest (line 229) | fn get_socket_digest(&self) -> Option<Arc<SocketDigest>>;
    method set_socket_digest (line 230) | fn set_socket_digest(&mut self, _socket_digest: SocketDigest) {}

FILE: pingora-core/src/protocols/http/body_buffer.rs
  type FixedBuffer (line 19) | pub struct FixedBuffer {
    method new (line 26) | pub fn new(capacity: usize) -> Self {
    method write_to_buffer (line 35) | pub fn write_to_buffer(&mut self, data: &Bytes) {
    method clear (line 43) | pub fn clear(&mut self) {
    method is_empty (line 47) | pub fn is_empty(&self) -> bool {
    method is_truncated (line 50) | pub fn is_truncated(&self) -> bool {
    method get_buffer (line 53) | pub fn get_buffer(&self) -> Option<Bytes> {

FILE: pingora-core/src/protocols/http/bridge/grpc_web.rs
  type GrpcWebCtx (line 27) | pub enum GrpcWebCtx {
    method init (line 40) | pub fn init(&mut self) {
    method request_header_filter (line 46) | pub fn request_header_filter(&mut self, req: &mut RequestHeader) {
    method response_header_filter (line 88) | pub fn response_header_filter(&mut self, resp: &mut ResponseHeader) {
    method response_trailer_filter (line 127) | pub fn response_trailer_filter(
  constant GRPC (line 36) | const GRPC: &str = "application/grpc";
  constant GRPC_WEB (line 37) | const GRPC_WEB: &str = "application/grpc-web";
  function non_grpc_web_request_ignored (line 190) | fn non_grpc_web_request_ignored() {
  function grpc_web_request_module_disabled_ignored (line 210) | fn grpc_web_request_module_disabled_ignored() {
  function grpc_web_request_upgrade (line 230) | fn grpc_web_request_upgrade() {
  function non_grpc_response_ignored (line 253) | fn non_grpc_response_ignored() {
  function grpc_response_module_disabled_ignored (line 271) | fn grpc_response_module_disabled_ignored() {
  function grpc_response_upgrade (line 287) | fn grpc_response_upgrade() {
  function grpc_response_informational_proxied (line 309) | fn grpc_response_informational_proxied() {
  function grpc_response_trailer_headers_convert_to_byte_buf (line 319) | fn grpc_response_trailer_headers_convert_to_byte_buf() {

FILE: pingora-core/src/protocols/http/client.rs
  type HttpSession (line 25) | pub enum HttpSession<S = ()> {
  function as_http1 (line 32) | pub fn as_http1(&self) -> Option<&Http1Session> {
  function as_http2 (line 40) | pub fn as_http2(&self) -> Option<&Http2Session> {
  function as_custom (line 48) | pub fn as_custom(&self) -> Option<&S> {
  function as_custom_mut (line 56) | pub fn as_custom_mut(&mut self) -> Option<&mut S> {
  function write_request_header (line 67) | pub async fn write_request_header(&mut self, req: Box<RequestHeader>) ->...
  function write_request_body (line 79) | pub async fn write_request_body(&mut self, data: Bytes, end: bool) -> Re...
  function finish_request_body (line 92) | pub async fn finish_request_body(&mut self) -> Result<()> {
  function set_read_timeout (line 106) | pub fn set_read_timeout(&mut self, timeout: Option<Duration>) {
  function set_write_timeout (line 117) | pub fn set_write_timeout(&mut self, timeout: Option<Duration>) {
  function read_response_header (line 128) | pub async fn read_response_header(&mut self) -> Result<()> {
  function read_response_body (line 142) | pub async fn read_response_body(&mut self) -> Result<Option<Bytes>> {
  function response_done (line 151) | pub fn response_done(&mut self) -> bool {
  function shutdown (line 162) | pub async fn shutdown(&mut self) {
  function response_header (line 173) | pub fn response_header(&self) -> Option<&ResponseHeader> {
  function digest (line 185) | pub fn digest(&self) -> Option<&Digest> {
  function digest_mut (line 196) | pub fn digest_mut(&mut self) -> Option<&mut Digest> {
  function server_addr (line 205) | pub fn server_addr(&self) -> Option<&SocketAddr> {
  function client_addr (line 214) | pub fn client_addr(&self) -> Option<&SocketAddr> {
  function stream (line 224) | pub fn stream(&self) -> Option<&Stream> {

FILE: pingora-core/src/protocols/http/compression/brotli.rs
  type Decompressor (line 24) | pub struct Decompressor {
    method new (line 32) | pub fn new() -> Self {
  method encode (line 44) | fn encode(&mut self, input: &[u8], end: bool) -> Result<Bytes> {
  method stat (line 73) | fn stat(&self) -> (&'static str, usize, usize, Duration) {
  type Compressor (line 78) | pub struct Compressor {
    method new (line 86) | pub fn new(level: u32) -> Self {
  method encode (line 98) | fn encode(&mut self, input: &[u8], end: bool) -> Result<Bytes> {
  method stat (line 122) | fn stat(&self) -> (&'static str, usize, usize, Duration) {
  function decompress_brotli_data (line 132) | fn decompress_brotli_data() {
  function compress_brotli_data (line 148) | fn compress_brotli_data() {

FILE: pingora-core/src/protocols/http/compression/gzip.rs
  type Decompressor (line 23) | pub struct Decompressor {
    method new (line 31) | pub fn new() -> Self {
  method encode (line 42) | fn encode(&mut self, input: &[u8], end: bool) -> Result<Bytes> {
  method stat (line 70) | fn stat(&self) -> (&'static str, usize, usize, Duration) {
  type Compressor (line 75) | pub struct Compressor {
    method new (line 84) | pub fn new(level: u32) -> Compressor {
  method encode (line 96) | fn encode(&mut self, input: &[u8], end: bool) -> Result<Bytes> {
  method stat (line 113) | fn stat(&self) -> (&'static str, usize, usize, Duration) {
  type Target (line 120) | type Target = GzDecoder<Vec<u8>>;
  method deref (line 122) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 128) | fn deref_mut(&mut self) -> &mut Self::Target {
  type Target (line 134) | type Target = GzEncoder<Vec<u8>>;
  method deref (line 136) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 142) | fn deref_mut(&mut self) -> &mut Self::Target {
  function gzip_data (line 152) | fn gzip_data() {
  function gunzip_data (line 169) | fn gunzip_data() {

FILE: pingora-core/src/protocols/http/compression/mod.rs
  constant COMPRESSION_ERROR (line 38) | pub const COMPRESSION_ERROR: ErrorType = ErrorType::new("CompressionErro...
  type Encode (line 42) | pub trait Encode {
    method encode (line 46) | fn encode(&mut self, input: &[u8], end: bool) -> Result<Bytes>;
    method stat (line 49) | fn stat(&self) -> (&'static str, usize, usize, Duration);
  type ResponseCompressionCtx (line 68) | pub struct ResponseCompressionCtx(CtxInner);
    method new (line 96) | pub fn new(compression_level: u32, decompress_enable: bool, preserve_e...
    method is_enabled (line 108) | pub fn is_enabled(&self) -> bool {
    method get_info (line 121) | pub fn get_info(&self) -> Option<(&'static str, usize, usize, Duration...
    method adjust_level (line 131) | pub fn adjust_level(&mut self, new_level: u32) {
    method adjust_algorithm_level (line 146) | pub fn adjust_algorithm_level(&mut self, algorithm: Algorithm, new_lev...
    method adjust_decompression (line 161) | pub fn adjust_decompression(&mut self, enabled: bool) {
    method adjust_algorithm_decompression (line 175) | pub fn adjust_algorithm_decompression(&mut self, algorithm: Algorithm,...
    method adjust_preserve_etag (line 189) | pub fn adjust_preserve_etag(&mut self, enabled: bool) {
    method adjust_algorithm_preserve_etag (line 201) | pub fn adjust_algorithm_preserve_etag(&mut self, algorithm: Algorithm,...
    method set_dictionary (line 213) | pub fn set_dictionary(&mut self, dictionary_bytes: Bytes, dictionary_h...
    method has_dictionary (line 226) | pub fn has_dictionary(&self) -> bool {
    method clear_dictionary (line 236) | pub fn clear_dictionary(&mut self) {
    method request_filter (line 246) | pub fn request_filter(&mut self, req: &RequestHeader) {
    method response_header_filter (line 262) | pub fn response_header_filter(&mut self, resp: &mut ResponseHeader, en...
    method response_body_filter (line 334) | pub fn response_body_filter(&mut self, data: Option<&Bytes>, end: bool...
    method response_filter (line 360) | pub fn response_filter(&mut self, t: &mut HttpTask) {
  type DictionaryData (line 72) | pub struct DictionaryData {
  type CtxInner (line 77) | enum CtxInner {
  type Algorithm (line 386) | pub enum Algorithm {
    method as_str (line 399) | pub fn as_str(&self) -> &'static str {
    method compressor (line 411) | pub fn compressor(&self, level: u32) -> Option<Box<dyn Encode + Send +...
    method maybe_compressor_with_dictionary (line 424) | pub fn maybe_compressor_with_dictionary(
    method decompressor (line 448) | pub fn decompressor(&self, enabled: bool) -> Option<Box<dyn Encode + S...
    method index (line 460) | pub fn index(&self) -> usize {
    method from (line 466) | fn from(s: &str) -> Self {
  type Action (line 489) | enum Action {
  function parse_accept_encoding (line 496) | fn parse_accept_encoding(accept_encoding: Option<&http::HeaderValue>, li...
  function test_accept_encoding_req_header (line 531) | fn test_accept_encoding_req_header() {
  function depends_on_accept_encoding (line 561) | fn depends_on_accept_encoding(
  function test_decide_on_accept_encoding (line 574) | fn test_decide_on_accept_encoding() {
  function decide_action (line 602) | fn decide_action(resp: &ResponseHeader, accept_encoding: &[Algorithm]) -...
  function test_decide_action (line 643) | fn test_decide_action() {
  function compressible (line 747) | fn compressible(resp: &ResponseHeader) -> bool {
  function add_vary_header (line 784) | fn add_vary_header(resp: &mut ResponseHeader, value: &http::header::Head...
  function test_add_vary_header (line 819) | fn test_add_vary_header() {
  function adjust_response_header (line 870) | fn adjust_response_header(resp: &mut ResponseHeader, action: &Action, pr...
  function test_adjust_response_header (line 934) | fn test_adjust_response_header() {
  constant TEST_DICTIONARY (line 1013) | const TEST_DICTIONARY: &[u8] = b"The quick brown fox jumps over the lazy...
  function test_dictionary_hash (line 1017) | fn test_dictionary_hash() -> [u8; 32] {
  function set_and_clear_dictionary (line 1026) | fn set_and_clear_dictionary() {
  function dcz_compression_with_dictionary (line 1038) | fn dcz_compression_with_dictionary() {
  function dcz_without_dictionary_no_compression (line 1068) | fn dcz_without_dictionary_no_compression() {
  function dcz_no_fallback_without_dictionary (line 1086) | fn dcz_no_fallback_without_dictionary() {
  function maybe_compressor_with_dictionary_dcz_only (line 1105) | fn maybe_compressor_with_dictionary_dcz_only() {
  function dcz_full_flow (line 1131) | fn dcz_full_flow() {

FILE: pingora-core/src/protocols/http/compression/zstd.rs
  constant DCZ_MAGIC (line 24) | pub const DCZ_MAGIC: [u8; 8] = [0x5e, 0x2a, 0x4d, 0x18, 0x20, 0x00, 0x00...
  constant DCZ_HEADER_SIZE (line 27) | pub const DCZ_HEADER_SIZE: usize = 40;
  type Compressor (line 29) | pub struct Compressor {
    method new (line 37) | pub fn new(level: u32) -> Self {
  method encode (line 50) | fn encode(&mut self, input: &[u8], end: bool) -> Result<Bytes> {
  method stat (line 74) | fn stat(&self) -> (&'static str, usize, usize, Duration) {
  type DictionaryCompressor (line 81) | pub struct DictionaryCompressor {
    method new (line 91) | pub fn new(level: u32, dictionary: &[u8], dictionary_hash: [u8; 32]) -...
    method build_header (line 107) | fn build_header(&self) -> [u8; DCZ_HEADER_SIZE] {
  method encode (line 116) | fn encode(&mut self, input: &[u8], end: bool) -> Result<Bytes> {
  method stat (line 147) | fn stat(&self) -> (&'static str, usize, usize, Duration) {
  function compress_zstd_data (line 157) | fn compress_zstd_data() {
  constant TEST_DICTIONARY (line 176) | const TEST_DICTIONARY: &[u8] = b"The quick brown fox jumps over the lazy...
  function test_dictionary_hash (line 185) | fn test_dictionary_hash() -> [u8; 32] {
  function compress_dcz_prepends_header (line 203) | fn compress_dcz_prepends_header() {
  function compress_dcz_header_written_once (line 220) | fn compress_dcz_header_written_once() {
  function compress_dcz_stats (line 235) | fn compress_dcz_stats() {
  function compress_dcz_empty_input (line 250) | fn compress_dcz_empty_input() {
  function compress_dcz_streaming (line 260) | fn compress_dcz_streaming() {
  function compress_dcz_achieves_compression (line 281) | fn compress_dcz_achieves_compression() {
  function compress_dcz_roundtrip (line 295) | fn compress_dcz_roundtrip() {

FILE: pingora-core/src/protocols/http/conditional_filter.rs
  function not_modified_filter (line 25) | pub fn not_modified_filter(req: &RequestHeader, resp: &ResponseHeader) -...
  function trim_ascii_start (line 75) | fn trim_ascii_start(mut bytes: &[u8]) -> &[u8] {
  function weak_validate_etag (line 91) | pub fn weak_validate_etag(input_etag_header: &[u8], target_etag: &[u8]) ...
  function req_header_as_http_date (line 160) | pub fn req_header_as_http_date<H>(req: &RequestHeader, header_name: H) -...
  function resp_header_as_http_date (line 171) | pub fn resp_header_as_http_date<H>(
  function parse_bytes_as_http_date (line 184) | fn parse_bytes_as_http_date(bytes: &[u8]) -> Result<HttpDate> {
  function to_304 (line 194) | pub fn to_304(resp: &mut ResponseHeader) {
  function test_if_modified_since (line 217) | fn test_if_modified_since() {
  function test_weak_validate_etag (line 249) | fn test_weak_validate_etag() {
  function test_weak_validate_etag_unquoted (line 297) | fn test_weak_validate_etag_unquoted() {

FILE: pingora-core/src/protocols/http/custom/client.rs
  type Session (line 30) | pub trait Session: Send + Sync + Unpin + 'static {
    method write_request_header (line 31) | async fn write_request_header(&mut self, req: Box<RequestHeader>, end:...
    method write_request_body (line 33) | async fn write_request_body(&mut self, data: Bytes, end: bool) -> Resu...
    method finish_request_body (line 35) | async fn finish_request_body(&mut self) -> Result<()>;
    method set_read_timeout (line 37) | fn set_read_timeout(&mut self, timeout: Option<Duration>);
    method set_write_timeout (line 39) | fn set_write_timeout(&mut self, timeout: Option<Duration>);
    method read_response_header (line 41) | async fn read_response_header(&mut self) -> Result<()>;
    method read_response_body (line 43) | async fn read_response_body(&mut self) -> Result<Option<Bytes>>;
    method response_finished (line 45) | fn response_finished(&self) -> bool;
    method shutdown (line 47) | async fn shutdown(&mut self, code: u32, ctx: &str);
    method response_header (line 49) | fn response_header(&self) -> Option<&ResponseHeader>;
    method was_upgraded (line 51) | fn was_upgraded(&self) -> bool;
    method digest (line 53) | fn digest(&self) -> Option<&Digest>;
    method digest_mut (line 55) | fn digest_mut(&mut self) -> Option<&mut Digest>;
    method server_addr (line 57) | fn server_addr(&self) -> Option<&SocketAddr>;
    method client_addr (line 59) | fn client_addr(&self) -> Option<&SocketAddr>;
    method read_trailers (line 61) | async fn read_trailers(&mut self) -> Result<Option<HeaderMap>>;
    method fd (line 63) | fn fd(&self) -> UniqueIDType;
    method check_response_end_or_error (line 65) | async fn check_response_end_or_error(&mut self, headers: bool) -> Resu...
    method take_request_body_writer (line 67) | fn take_request_body_writer(&mut self) -> Option<Box<dyn BodyWrite>>;
    method finish_custom (line 69) | async fn finish_custom(&mut self) -> Result<()>;
    method take_custom_message_reader (line 71) | fn take_custom_message_reader(
    method drain_custom_messages (line 75) | async fn drain_custom_messages(&mut self) -> Result<()>;
    method take_custom_message_writer (line 77) | fn take_custom_message_writer(&mut self) -> Option<Box<dyn CustomMessa...
    method write_request_header (line 83) | async fn write_request_header(&mut self, _req: Box<RequestHeader>, _en...
    method write_request_body (line 87) | async fn write_request_body(&mut self, _data: Bytes, _end: bool) -> Re...
    method finish_request_body (line 91) | async fn finish_request_body(&mut self) -> Result<()> {
    method set_read_timeout (line 95) | fn set_read_timeout(&mut self, _timeout: Option<Duration>) {
    method set_write_timeout (line 99) | fn set_write_timeout(&mut self, _timeout: Option<Duration>) {
    method read_response_header (line 103) | async fn read_response_header(&mut self) -> Result<()> {
    method read_response_body (line 107) | async fn read_response_body(&mut self) -> Result<Option<Bytes>> {
    method response_finished (line 111) | fn response_finished(&self) -> bool {
    method shutdown (line 115) | async fn shutdown(&mut self, _code: u32, _ctx: &str) {
    method response_header (line 119) | fn response_header(&self) -> Option<&ResponseHeader> {
    method was_upgraded (line 123) | fn was_upgraded(&self) -> bool {
    method digest (line 127) | fn digest(&self) -> Option<&Digest> {
    method digest_mut (line 131) | fn digest_mut(&mut self) -> Option<&mut Digest> {
    method server_addr (line 135) | fn server_addr(&self) -> Option<&SocketAddr> {
    method client_addr (line 139) | fn client_addr(&self) -> Option<&SocketAddr> {
    method finish_custom (line 143) | async fn finish_custom(&mut self) -> Result<()> {
    method read_trailers (line 147) | async fn read_trailers(&mut self) -> Result<Option<HeaderMap>> {
    method fd (line 151) | fn fd(&self) -> UniqueIDType {
    method check_response_end_or_error (line 155) | async fn check_response_end_or_error(&mut self, _headers: bool) -> Res...
    method take_custom_message_reader (line 159) | fn take_custom_message_reader(
    method drain_custom_messages (line 165) | async fn drain_custom_messages(&mut self) -> Result<()> {
    method take_custom_message_writer (line 169) | fn take_custom_message_writer(&mut self) -> Option<Box<dyn CustomMessa...
    method take_request_body_writer (line 173) | fn take_request_body_writer(&mut self) -> Option<Box<dyn BodyWrite>> {

FILE: pingora-core/src/protocols/http/custom/mod.rs
  constant CUSTOM_MESSAGE_QUEUE_SIZE (line 27) | pub const CUSTOM_MESSAGE_QUEUE_SIZE: usize = 128;
  function is_informational_except_101 (line 29) | pub fn is_informational_except_101<T: PartialOrd<u32>>(code: T) -> bool {
  type CustomMessageWrite (line 37) | pub trait CustomMessageWrite: Send + Sync + Unpin + 'static {
    method set_write_timeout (line 38) | fn set_write_timeout(&mut self, timeout: Option<Duration>);
    method write_custom_message (line 39) | async fn write_custom_message(&mut self, msg: Bytes) -> Result<()>;
    method finish_custom (line 40) | async fn finish_custom(&mut self) -> Result<()>;
    method set_write_timeout (line 46) | fn set_write_timeout(&mut self, _timeout: Option<Duration>) {}
    method write_custom_message (line 48) | async fn write_custom_message(&mut self, msg: Bytes) -> Result<()> {
    method finish_custom (line 53) | async fn finish_custom(&mut self) -> Result<()> {
  type BodyWrite (line 60) | pub trait BodyWrite: Send + Sync + Unpin + 'static {
    method write_all_buf (line 61) | async fn write_all_buf(&mut self, data: &mut Bytes) -> Result<()>;
    method finish (line 62) | async fn finish(&mut self) -> Result<()>;
    method cleanup (line 63) | async fn cleanup(&mut self) -> Result<()>;
    method upgrade_body_writer (line 64) | fn upgrade_body_writer(&mut self);
  function drain_custom_messages (line 67) | pub async fn drain_custom_messages(

FILE: pingora-core/src/protocols/http/custom/server.rs
  type Session (line 30) | pub trait Session: Send + Sync + Unpin + 'static {
    method req_header (line 31) | fn req_header(&self) -> &RequestHeader;
    method req_header_mut (line 33) | fn req_header_mut(&mut self) -> &mut RequestHeader;
    method read_body_bytes (line 35) | async fn read_body_bytes(&mut self) -> Result<Option<Bytes>>;
    method drain_request_body (line 37) | async fn drain_request_body(&mut self) -> Result<()>;
    method write_response_header (line 39) | async fn write_response_header(&mut self, resp: Box<ResponseHeader>, e...
    method write_response_header_ref (line 41) | async fn write_response_header_ref(&mut self, resp: &ResponseHeader, e...
    method write_body (line 43) | async fn write_body(&mut self, data: Bytes, end: bool) -> Result<()>;
    method write_trailers (line 45) | async fn write_trailers(&mut self, trailers: HeaderMap) -> Result<()>;
    method response_duplex_vec (line 47) | async fn response_duplex_vec(&mut self, tasks: Vec<HttpTask>) -> Resul...
    method set_read_timeout (line 49) | fn set_read_timeout(&mut self, timeout: Option<Duration>);
    method get_read_timeout (line 51) | fn get_read_timeout(&self) -> Option<Duration>;
    method set_write_timeout (line 53) | fn set_write_timeout(&mut self, timeout: Option<Duration>);
    method get_write_timeout (line 55) | fn get_write_timeout(&self) -> Option<Duration>;
    method set_total_drain_timeout (line 57) | fn set_total_drain_timeout(&mut self, timeout: Option<Duration>);
    method get_total_drain_timeout (line 59) | fn get_total_drain_timeout(&self) -> Option<Duration>;
    method request_summary (line 61) | fn request_summary(&self) -> String;
    method response_written (line 63) | fn response_written(&self) -> Option<&ResponseHeader>;
    method shutdown (line 65) | async fn shutdown(&mut self, code: u32, ctx: &str);
    method is_body_done (line 67) | fn is_body_done(&mut self) -> bool;
    method finish (line 69) | async fn finish(&mut self) -> Result<()>;
    method is_body_empty (line 71) | fn is_body_empty(&mut self) -> bool;
    method read_body_or_idle (line 73) | async fn read_body_or_idle(&mut self, no_body_expected: bool) -> Resul...
    method body_bytes_sent (line 75) | fn body_bytes_sent(&self) -> usize;
    method body_bytes_read (line 77) | fn body_bytes_read(&self) -> usize;
    method digest (line 79) | fn digest(&self) -> Option<&Digest>;
    method digest_mut (line 81) | fn digest_mut(&mut self) -> Option<&mut Digest>;
    method client_addr (line 83) | fn client_addr(&self) -> Option<&SocketAddr>;
    method server_addr (line 85) | fn server_addr(&self) -> Option<&SocketAddr>;
    method pseudo_raw_h1_request_header (line 87) | fn pseudo_raw_h1_request_header(&self) -> Bytes;
    method enable_retry_buffering (line 89) | fn enable_retry_buffering(&mut self);
    method retry_buffer_truncated (line 91) | fn retry_buffer_truncated(&self) -> bool;
    method get_retry_buffer (line 93) | fn get_retry_buffer(&self) -> Option<Bytes>;
    method finish_custom (line 95) | async fn finish_custom(&mut self) -> Result<()>;
    method take_custom_message_reader (line 97) | fn take_custom_message_reader(
    method restore_custom_message_reader (line 101) | fn restore_custom_message_reader(
    method take_custom_message_writer (line 106) | fn take_custom_message_writer(&mut self) -> Option<Box<dyn CustomMessa...
    method restore_custom_message_writer (line 108) | fn restore_custom_message_writer(&mut self, writer: Box<dyn CustomMess...
    method is_upgrade_req (line 113) | fn is_upgrade_req(&self) -> bool {
    method was_upgraded (line 120) | fn was_upgraded(&self) -> bool {
    method req_header (line 128) | fn req_header(&self) -> &RequestHeader {
    method req_header_mut (line 132) | fn req_header_mut(&mut self) -> &mut RequestHeader {
    method read_body_bytes (line 136) | async fn read_body_bytes(&mut self) -> Result<Option<Bytes>> {
    method drain_request_body (line 140) | async fn drain_request_body(&mut self) -> Result<()> {
    method write_response_header (line 144) | async fn write_response_header(
    method write_response_header_ref (line 152) | async fn write_response_header_ref(
    method write_body (line 160) | async fn write_body(&mut self, _data: Bytes, _end: bool) -> Result<()> {
    method write_trailers (line 164) | async fn write_trailers(&mut self, _trailers: HeaderMap) -> Result<()> {
    method response_duplex_vec (line 168) | async fn response_duplex_vec(&mut self, _tasks: Vec<HttpTask>) -> Resu...
    method set_read_timeout (line 172) | fn set_read_timeout(&mut self, _timeout: Option<Duration>) {
    method get_read_timeout (line 176) | fn get_read_timeout(&self) -> Option<Duration> {
    method set_write_timeout (line 180) | fn set_write_timeout(&mut self, _timeout: Option<Duration>) {
    method get_write_timeout (line 184) | fn get_write_timeout(&self) -> Option<Duration> {
    method set_total_drain_timeout (line 188) | fn set_total_drain_timeout(&mut self, _timeout: Option<Duration>) {
    method get_total_drain_timeout (line 192) | fn get_total_drain_timeout(&self) -> Option<Duration> {
    method request_summary (line 196) | fn request_summary(&self) -> String {
    method response_written (line 200) | fn response_written(&self) -> Option<&ResponseHeader> {
    method shutdown (line 204) | async fn shutdown(&mut self, _code: u32, _ctx: &str) {
    method is_body_done (line 208) | fn is_body_done(&mut self) -> bool {
    method finish (line 212) | async fn finish(&mut self) -> Result<()> {
    method is_body_empty (line 216) | fn is_body_empty(&mut self) -> bool {
    method read_body_or_idle (line 220) | async fn read_body_or_idle(&mut self, _no_body_expected: bool) -> Resu...
    method body_bytes_sent (line 224) | fn body_bytes_sent(&self) -> usize {
    method body_bytes_read (line 228) | fn body_bytes_read(&self) -> usize {
    method digest (line 232) | fn digest(&self) -> Option<&Digest> {
    method digest_mut (line 236) | fn digest_mut(&mut self) -> Option<&mut Digest> {
    method client_addr (line 240) | fn client_addr(&self) -> Option<&SocketAddr> {
    method server_addr (line 244) | fn server_addr(&self) -> Option<&SocketAddr> {
    method pseudo_raw_h1_request_header (line 248) | fn pseudo_raw_h1_request_header(&self) -> Bytes {
    method enable_retry_buffering (line 252) | fn enable_retry_buffering(&mut self) {
    method retry_buffer_truncated (line 256) | fn retry_buffer_truncated(&self) -> bool {
    method get_retry_buffer (line 260) | fn get_retry_buffer(&self) -> Option<Bytes> {
    method finish_custom (line 264) | async fn finish_custom(&mut self) -> Result<()> {
    method take_custom_message_reader (line 268) | fn take_custom_message_reader(
    method restore_custom_message_reader (line 274) | fn restore_custom_message_reader(
    method take_custom_message_writer (line 281) | fn take_custom_message_writer(&mut self) -> Option<Box<dyn CustomMessa...
    method restore_custom_message_writer (line 285) | fn restore_custom_message_writer(
    method is_upgrade_req (line 292) | fn is_upgrade_req(&self) -> bool {
    method was_upgraded (line 296) | fn was_upgraded(&self) -> bool {

FILE: pingora-core/src/protocols/http/date.rs
  function to_date_string (line 20) | fn to_date_string(epoch_sec: i64) -> String {
  type CacheableDate (line 25) | struct CacheableDate {
    method new (line 31) | pub fn new() -> Self {
    method update (line 41) | pub fn update(&mut self, d_now: Duration) {
    method get_date (line 48) | pub fn get_date(&mut self) -> HeaderValue {
  function get_cached_date (line 62) | pub fn get_cached_date() -> HeaderValue {
  function now_date_header (line 70) | fn now_date_header() -> HeaderValue {
  function test_date_string (line 81) | fn test_date_string() {
  function test_date_cached (line 87) | fn test_date_cached() {

FILE: pingora-core/src/protocols/http/error_resp.rs
  function gen_error_response (line 26) | pub fn gen_error_response(code: u16) -> ResponseHeader {

FILE: pingora-core/src/protocols/http/mod.rs
  constant SERVER_NAME (line 33) | pub const SERVER_NAME: &[u8; 7] = b"Pingora";
  type HttpTask (line 37) | pub enum HttpTask {
    method is_end (line 54) | pub fn is_end(&self) -> bool {
    method type_str (line 66) | pub fn type_str(&self) -> &'static str {

FILE: pingora-core/src/protocols/http/server.rs
  type Session (line 33) | pub enum Session {
    method new_http1 (line 42) | pub fn new_http1(stream: Stream) -> Self {
    method new_http2 (line 47) | pub fn new_http2(session: SessionV2) -> Self {
    method new_subrequest (line 52) | pub fn new_subrequest(session: SessionSubrequest) -> Self {
    method new_custom (line 57) | pub fn new_custom(session: Box<dyn SessionCustom>) -> Self {
    method is_http2 (line 62) | pub fn is_http2(&self) -> bool {
    method is_subrequest (line 67) | pub fn is_subrequest(&self) -> bool {
    method is_custom (line 72) | pub fn is_custom(&self) -> bool {
    method read_request (line 81) | pub async fn read_request(&mut self) -> Result<bool> {
    method req_header (line 100) | pub fn req_header(&self) -> &RequestHeader {
    method req_header_mut (line 112) | pub fn req_header_mut(&mut self) -> &mut RequestHeader {
    method get_header (line 125) | pub fn get_header<K: AsHeaderName>(&self, key: K) -> Option<&HeaderVal...
    method get_header_bytes (line 131) | pub fn get_header_bytes<K: AsHeaderName>(&self, key: K) -> &[u8] {
    method read_request_body (line 136) | pub async fn read_request_body(&mut self) -> Result<Option<Bytes>> {
    method drain_request_body (line 149) | pub async fn drain_request_body(&mut self) -> Result<()> {
    method write_response_header (line 161) | pub async fn write_response_header(&mut self, resp: Box<ResponseHeader...
    method write_response_header_ref (line 177) | pub async fn write_response_header_ref(&mut self, resp: &ResponseHeade...
    method write_response_body (line 193) | pub async fn write_response_body(&mut self, data: Bytes, end: bool) ->...
    method write_response_trailers (line 220) | pub async fn write_response_trailers(&mut self, trailers: HeaderMap) -...
    method finish (line 233) | pub async fn finish(self) -> Result<Option<Stream>> {
    method on_proxy_failure (line 260) | pub fn on_proxy_failure(&mut self, e: Box<Error>) {
    method response_duplex_vec (line 270) | pub async fn response_duplex_vec(&mut self, tasks: Vec<HttpTask>) -> R...
    method set_keepalive (line 281) | pub fn set_keepalive(&mut self, duration: Option<u64>) {
    method get_keepalive (line 292) | pub fn get_keepalive(&self) -> Option<u64> {
    method set_keepalive_reuses_remaining (line 303) | pub fn set_keepalive_reuses_remaining(&mut self, reuses: Option<u32>) {
    method get_keepalive_reuses_remaining (line 312) | pub fn get_keepalive_reuses_remaining(&self) -> Option<u32> {
    method set_read_timeout (line 324) | pub fn set_read_timeout(&mut self, timeout: Option<Duration>) {
    method get_read_timeout (line 334) | pub fn get_read_timeout(&self) -> Option<Duration> {
    method set_write_timeout (line 346) | pub fn set_write_timeout(&mut self, timeout: Option<Duration>) {
    method get_write_timeout (line 356) | pub fn get_write_timeout(&self) -> Option<Duration> {
    method set_total_drain_timeout (line 371) | pub fn set_total_drain_timeout(&mut self, timeout: Option<Duration>) {
    method get_total_drain_timeout (line 381) | pub fn get_total_drain_timeout(&self) -> Option<Duration> {
    method set_min_send_rate (line 400) | pub fn set_min_send_rate(&mut self, rate: Option<usize>) {
    method set_ignore_info_resp (line 417) | pub fn set_ignore_info_resp(&mut self, ignore: bool) {
    method set_close_on_response_before_downstream_finish (line 430) | pub fn set_close_on_response_before_downstream_finish(&mut self, close...
    method request_summary (line 441) | pub fn request_summary(&self) -> String {
    method response_written (line 452) | pub fn response_written(&self) -> Option<&ResponseHeader> {
    method shutdown (line 465) | pub async fn shutdown(&mut self) {
    method to_h1_raw (line 474) | pub fn to_h1_raw(&self) -> Bytes {
    method is_body_done (line 484) | pub fn is_body_done(&mut self) -> bool {
    method finish_body (line 498) | pub async fn finish_body(&mut self) -> Result<()> {
    method generate_error (line 507) | pub fn generate_error(error: u16) -> ResponseHeader {
    method respond_error (line 517) | pub async fn respond_error(&mut self, error: u16) -> Result<()> {
    method respond_error_with_body (line 522) | pub async fn respond_error_with_body(&mut self, error: u16, body: Byte...
    method write_error_response (line 532) | pub async fn write_error_response(&mut self, resp: ResponseHeader, bod...
    method is_body_empty (line 564) | pub fn is_body_empty(&mut self) -> bool {
    method retry_buffer_truncated (line 573) | pub fn retry_buffer_truncated(&self) -> bool {
    method enable_retry_buffering (line 582) | pub fn enable_retry_buffering(&mut self) {
    method get_retry_buffer (line 591) | pub fn get_retry_buffer(&self) -> Option<Bytes> {
    method read_body_or_idle (line 602) | pub async fn read_body_or_idle(&mut self, no_body_expected: bool) -> R...
    method as_http1 (line 611) | pub fn as_http1(&self) -> Option<&SessionV1> {
    method as_http2 (line 620) | pub fn as_http2(&self) -> Option<&SessionV2> {
    method as_subrequest (line 629) | pub fn as_subrequest(&self) -> Option<&SessionSubrequest> {
    method as_subrequest_mut (line 638) | pub fn as_subrequest_mut(&mut self) -> Option<&mut SessionSubrequest> {
    method as_custom (line 647) | pub fn as_custom(&self) -> Option<&dyn SessionCustom> {
    method as_custom_mut (line 656) | pub fn as_custom_mut(&mut self) -> Option<&mut Box<dyn SessionCustom>> {
    method write_continue_response (line 666) | pub async fn write_continue_response(&mut self) -> Result<()> {
    method is_upgrade_req (line 686) | pub fn is_upgrade_req(&self) -> bool {
    method was_upgraded (line 696) | pub fn was_upgraded(&self) -> bool {
    method body_bytes_sent (line 706) | pub fn body_bytes_sent(&self) -> usize {
    method body_bytes_read (line 716) | pub fn body_bytes_read(&self) -> usize {
    method digest (line 726) | pub fn digest(&self) -> Option<&Digest> {
    method digest_mut (line 738) | pub fn digest_mut(&mut self) -> Option<&mut Digest> {
    method client_addr (line 748) | pub fn client_addr(&self) -> Option<&SocketAddr> {
    method server_addr (line 758) | pub fn server_addr(&self) -> Option<&SocketAddr> {
    method stream (line 769) | pub fn stream(&self) -> Option<&Stream> {

FILE: pingora-core/src/protocols/http/subrequest/body.rs
  constant PREMATURE_BODY_END (line 35) | pub const PREMATURE_BODY_END: ErrorType = ErrorType::new("PrematureBodyE...
  type ParseState (line 38) | pub enum ParseState {
  type PS (line 46) | type PS = ParseState;
  type BodyReader (line 48) | pub struct BodyReader {
    method new (line 54) | pub fn new(notify_wants_body: Option<oneshot::Sender<()>>) -> Self {
    method need_init (line 62) | pub fn need_init(&self) -> bool {
    method init_content_length (line 66) | pub fn init_content_length(&mut self, cl: usize) {
    method init_close_delimited (line 75) | pub fn init_close_delimited(&mut self) {
    method convert_to_close_delimited (line 81) | pub fn convert_to_close_delimited(&mut self) {
    method body_done (line 91) | pub fn body_done(&self) -> bool {
    method body_empty (line 95) | pub fn body_empty(&self) -> bool {
    method read_body (line 99) | pub async fn read_body(&mut self, rx: &mut mpsc::Receiver<HttpTask>) -...
    method do_read_body (line 109) | pub async fn do_read_body(
    method do_read_body_until_closed (line 169) | pub async fn do_read_body_until_closed(
  type BodyMode (line 209) | pub enum BodyMode {
  type BM (line 216) | type BM = BodyMode;
  type BodyWriter (line 218) | pub struct BodyWriter {
    method new (line 223) | pub fn new() -> Self {
    method init_close_delimited (line 229) | pub fn init_close_delimited(&mut self) {
    method init_content_length (line 233) | pub fn init_content_length(&mut self, cl: usize) {
    method write_body (line 237) | pub async fn write_body(
    method finished (line 251) | pub fn finished(&self) -> bool {
    method do_write_body (line 259) | async fn do_write_body(
    method do_write_until_close_body (line 289) | async fn do_write_until_close_body(
    method finish (line 309) | pub async fn finish(&mut self, sender: &mut mpsc::Sender<HttpTask>) ->...
    method do_finish_body (line 318) | async fn do_finish_body(&mut self, tx: &mut mpsc::Sender<HttpTask>) ->...
    method do_finish_until_close_body (line 338) | async fn do_finish_until_close_body(
    method write_trailers (line 355) | pub async fn write_trailers(
  function init_log (line 373) | fn init_log() {
  constant TASK_BUFFER_SIZE (line 377) | const TASK_BUFFER_SIZE: usize = 4;
  function read_with_body_content_length (line 380) | async fn read_with_body_content_length() {
  function read_with_body_content_length_2 (line 397) | async fn read_with_body_content_length_2() {
  function read_with_body_content_length_empty_task (line 422) | async fn read_with_body_content_length_empty_task() {
  function read_with_body_content_length_less (line 456) | async fn read_with_body_content_length_less() {
  function read_with_body_content_length_more (line 478) | async fn read_with_body_content_length_more() {
  function read_with_body_until_close (line 503) | async fn read_with_body_until_close() {
  function write_body_cl (line 533) | async fn write_body_cl() {
  function write_body_until_close (line 576) | async fn write_body_until_close() {

FILE: pingora-core/src/protocols/http/subrequest/dummy.rs
  type DummyIO (line 30) | pub(crate) struct DummyIO(Cursor<Vec<u8>>);
    method new (line 33) | pub fn new(read_bytes: &[u8]) -> Self {
    method shutdown (line 100) | async fn shutdown(&mut self) -> () {}
  method poll_read (line 39) | fn poll_read(
  method poll_write (line 54) | fn poll_write(
  method poll_flush (line 62) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Resul...
  method poll_shutdown (line 65) | fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Re...
  method id (line 71) | fn id(&self) -> UniqueIDType {
  method get_timing_digest (line 79) | fn get_timing_digest(&self) -> Vec<Option<TimingDigest>> {
  method get_proxy_digest (line 85) | fn get_proxy_digest(&self) -> Option<Arc<ProxyDigest>> {
  method get_socket_digest (line 91) | fn get_socket_digest(&self) -> Option<Arc<SocketDigest>> {
  function test_dummy_io (line 104) | async fn test_dummy_io() {

FILE: pingora-core/src/protocols/http/subrequest/server.rs
  type HttpSession (line 57) | pub struct HttpSession {
    method new_from_session (line 108) | pub fn new_from_session(session: &GenericHttpSession) -> (Self, Subreq...
    method read_request (line 147) | pub async fn read_request(&mut self) -> Result<Option<usize>> {
    method validate_request (line 166) | pub fn validate_request(&self) -> Result<()> {
    method req_header (line 173) | pub fn req_header(&self) -> &RequestHeader {
    method req_header_mut (line 180) | pub fn req_header_mut(&mut self) -> &mut RequestHeader {
    method get_header (line 187) | pub fn get_header(&self, name: impl AsHeaderName) -> Option<&HeaderVal...
    method get_method (line 192) | pub(super) fn get_method(&self) -> Option<&http::Method> {
    method get_path (line 198) | pub(super) fn get_path(&self) -> &[u8] {
    method get_host (line 203) | pub(super) fn get_host(&self) -> &[u8] {
    method request_summary (line 208) | pub fn request_summary(&self) -> String {
    method is_upgrade_req (line 218) | pub fn is_upgrade_req(&self) -> bool {
    method get_header_bytes (line 223) | pub fn get_header_bytes(&self, name: impl AsHeaderName) -> &[u8] {
    method read_body_bytes (line 228) | pub async fn read_body_bytes(&mut self) -> Result<Option<Bytes>> {
    method do_read_body (line 238) | async fn do_read_body(&mut self) -> Result<Option<Bytes>> {
    method read_body (line 246) | async fn read_body(&mut self) -> Result<Option<Bytes>> {
    method do_drain_request_body (line 259) | async fn do_drain_request_body(&mut self) -> Result<()> {
    method drain_request_body (line 270) | pub async fn drain_request_body(&mut self) -> Result<()> {
    method is_body_done (line 287) | pub fn is_body_done(&mut self) -> bool {
    method is_body_empty (line 296) | pub fn is_body_empty(&mut self) -> bool {
    method write_response_header (line 303) | pub async fn write_response_header(&mut self, header: Box<ResponseHead...
    method response_written (line 371) | pub fn response_written(&self) -> Option<&ResponseHeader> {
    method is_upgrade (line 378) | pub fn is_upgrade(&self, header: &ResponseHeader) -> Option<bool> {
    method was_upgraded (line 388) | pub fn was_upgraded(&self) -> bool {
    method init_body_writer (line 392) | fn init_body_writer(&mut self, header: &ResponseHeader) {
    method write_response_header_ref (line 431) | pub async fn write_response_header_ref(&mut self, resp: &ResponseHeade...
    method do_write_body (line 435) | async fn do_write_body(&mut self, buf: Bytes) -> Result<Option<usize>> {
    method write_body (line 450) | pub async fn write_body(&mut self, buf: Bytes) -> Result<Option<usize>> {
    method maybe_force_close_body_reader (line 461) | fn maybe_force_close_body_reader(&mut self) {
    method finish (line 472) | pub async fn finish(&mut self) -> Result<Option<usize>> {
    method on_proxy_failure (line 490) | pub fn on_proxy_failure(&mut self, e: Box<Error>) {
    method body_bytes_sent (line 498) | pub fn body_bytes_sent(&self) -> usize {
    method body_bytes_read (line 503) | pub fn body_bytes_read(&self) -> usize {
    method is_chunked_encoding (line 507) | fn is_chunked_encoding(&self) -> bool {
    method clear_request_body_headers (line 515) | pub fn clear_request_body_headers(&mut self) {
    method init_body_reader (line 526) | fn init_body_reader(&mut self) {
    method retry_buffer_truncated (line 560) | pub fn retry_buffer_truncated(&self) -> bool {
    method enable_retry_buffering (line 566) | pub fn enable_retry_buffering(&mut self) {
    method get_retry_buffer (line 572) | pub fn get_retry_buffer(&self) -> Option<Bytes> {
    method idle (line 583) | pub async fn idle(&mut self) -> Result<HttpTask> {
    method read_body_or_idle (line 605) | pub async fn read_body_or_idle(&mut self, no_body_expected: bool) -> R...
    method get_headers_raw_bytes (line 618) | pub fn get_headers_raw_bytes(&self) -> Bytes {
    method shutdown (line 624) | pub fn shutdown(&mut self) {
    method set_read_timeout (line 631) | pub fn set_read_timeout(&mut self, timeout: Option<Duration>) {
    method get_read_timeout (line 636) | pub fn get_read_timeout(&self) -> Option<Duration> {
    method set_write_timeout (line 642) | pub fn set_write_timeout(&mut self, timeout: Option<Duration>) {
    method get_write_timeout (line 647) | pub fn get_write_timeout(&self) -> Option<Duration> {
    method set_total_drain_timeout (line 653) | pub fn set_total_drain_timeout(&mut self, timeout: Option<Duration>) {
    method get_total_drain_timeout (line 658) | pub fn get_total_drain_timeout(&self) -> Option<Duration> {
    method digest (line 663) | pub fn digest(&self) -> Option<&Digest> {
    method digest_mut (line 668) | pub fn digest_mut(&mut self) -> Option<&mut Digest> {
    method client_addr (line 673) | pub fn client_addr(&self) -> Option<&SocketAddr> {
    method server_addr (line 680) | pub fn server_addr(&self) -> Option<&SocketAddr> {
    method write_continue_response (line 687) | pub async fn write_continue_response(&mut self) -> Result<()> {
    method write_non_empty_body (line 698) | async fn write_non_empty_body(&mut self, data: Option<Bytes>, upgraded...
    method response_duplex (line 716) | async fn response_duplex(&mut self, task: HttpTask) -> Result<bool> {
    method response_duplex_vec (line 747) | pub async fn response_duplex_vec(&mut self, mut tasks: Vec<HttpTask>) ...
    method write_trailers (line 795) | pub async fn write_trailers(&mut self, trailers: Option<Box<HeaderMap>...
  type SubrequestHandle (line 82) | pub struct SubrequestHandle {
    method drain_tasks (line 95) | pub fn drain_tasks(mut self) -> tokio::task::JoinHandle<()> {
  function init_log (line 816) | fn init_log() {
  function session_from_input (line 820) | async fn session_from_input(input: &[u8]) -> (HttpSession, SubrequestHan...
  function build_upgrade_req (line 829) | async fn build_upgrade_req(upgrade: &str, conn: &str) -> (HttpSession, S...
  function build_req (line 834) | async fn build_req() -> (HttpSession, SubrequestHandle) {
  function read_basic (line 840) | async fn read_basic() {
  function read_upgrade_req (line 850) | async fn read_upgrade_req() {
  function read_upgrade_req_with_1xx_response (line 880) | async fn read_upgrade_req_with_1xx_response() {
  function write (line 894) | async fn write() {
  function write_informational (line 913) | async fn write_informational() {
  function write_101_switching_protocol (line 943) | async fn write_101_switching_protocol() {
  function write_body_cl (line 989) | async fn write_body_cl() {
  function write_body_until_close (line 1013) | async fn write_body_until_close() {
  function read_with_illegal (line 1033) | async fn read_with_illegal() {
  function test_write_body_write_timeout (line 1056) | async fn test_write_body_write_timeout() {
  function test_write_continue_resp (line 1082) | async fn test_write_continue_resp() {
  function session_from_input_no_validate (line 1094) | async fn session_from_input_no_validate(input: &[u8]) -> (HttpSession, S...
  function validate_request_rejects_invalid_content_length (line 1111) | async fn validate_request_rejects_invalid_content_length(#[case] invalid...
  function validate_request_accepts_valid_content_length (line 1133) | async fn validate_request_accepts_valid_content_length(#[case] valid_val...
  function validate_request_accepts_no_content_length (line 1145) | async fn validate_request_accepts_no_content_length() {
  constant POST_CL_UPGRADE_REQ (line 1153) | const POST_CL_UPGRADE_REQ: &[u8] = b"POST / HTTP/1.1\r\nHost: pingora.or...
  constant POST_CHUNKED_UPGRADE_REQ (line 1154) | const POST_CHUNKED_UPGRADE_REQ: &[u8] = b"POST / HTTP/1.1\r\nHost: pingo...
  constant POST_BODY_DATA (line 1155) | const POST_BODY_DATA: &[u8] = b"abcdefghij";
  function build_upgrade_req_with_body (line 1157) | async fn build_upgrade_req_with_body(header: &[u8]) -> (HttpSession, Sub...
  function read_upgrade_req_with_body (line 1170) | async fn read_upgrade_req_with_body(#[case] header: &[u8]) {

FILE: pingora-core/src/protocols/http/v1/body.rs
  constant BODY_BUFFER_SIZE (line 29) | const BODY_BUFFER_SIZE: usize = 1024 * 64;
  constant PARTIAL_CHUNK_HEAD_LIMIT (line 31) | const PARTIAL_CHUNK_HEAD_LIMIT: usize = 1024 * 8;
  constant TRAILER_SIZE_LIMIT (line 36) | const TRAILER_SIZE_LIMIT: usize = 1024 * 64;
  constant LAST_CHUNK (line 38) | const LAST_CHUNK: &[u8; 5] = &[b'0', CR, LF, CR, LF];
  constant CR (line 39) | const CR: u8 = b'\r';
  constant LF (line 40) | const LF: u8 = b'\n';
  constant CRLF (line 41) | const CRLF: &[u8; 2] = &[CR, LF];
  constant TRAILERS_END (line 43) | const TRAILERS_END: &[u8; 4] = &[CR, LF, CR, LF];
  constant INVALID_CHUNK (line 45) | pub const INVALID_CHUNK: ErrorType = ErrorType::new("InvalidChunk");
  constant INVALID_TRAILER_END (line 46) | pub const INVALID_TRAILER_END: ErrorType = ErrorType::new("InvalidTraile...
  constant PREMATURE_BODY_END (line 47) | pub const PREMATURE_BODY_END: ErrorType = ErrorType::new("PrematureBodyE...
  type ParseState (line 50) | pub enum ParseState {
    method finish (line 71) | pub fn finish(&self, additional_bytes: usize) -> Self {
    method done (line 81) | pub fn done(&self, additional_bytes: usize) -> Self {
    method read_final_chunk (line 91) | pub fn read_final_chunk(&self, remaining_buf_size: usize) -> Self {
    method partial_chunk (line 109) | pub fn partial_chunk(&self, bytes_read: usize, bytes_to_read: usize) -...
    method multi_chunk (line 117) | pub fn multi_chunk(&self, bytes_read: usize, buf_start_index: usize) -...
    method partial_chunk_head (line 127) | pub fn partial_chunk_head(&self, head_end: usize, head_size: usize) ->...
    method new_buf (line 136) | pub fn new_buf(&self, buf_end: usize) -> Self {
  type PS (line 68) | type PS = ParseState;
  type BodyReader (line 145) | pub struct BodyReader {
    method new (line 155) | pub fn new(upstream: bool) -> Self {
    method need_init (line 166) | pub fn need_init(&self) -> bool {
    method reinit (line 170) | pub fn reinit(&mut self) {
    method prepare_buf (line 174) | fn prepare_buf(&mut self, buf_to_rewind: &[u8]) {
    method init_chunked (line 190) | pub fn init_chunked(&mut self, buf_to_rewind: &[u8]) {
    method init_content_length (line 195) | pub fn init_content_length(&mut self, cl: usize, buf_to_rewind: &[u8]) {
    method init_close_delimited (line 213) | pub fn init_close_delimited(&mut self, buf_to_rewind: &[u8]) {
    method convert_to_close_delimited (line 222) | pub fn convert_to_close_delimited(&mut self) {
    method get_body (line 238) | pub fn get_body(&self, buf_ref: &BufRef) -> &[u8] {
    method get_body_overread (line 244) | pub fn get_body_overread(&self) -> Option<&[u8]> {
    method has_bytes_overread (line 248) | pub fn has_bytes_overread(&self) -> bool {
    method body_done (line 252) | pub fn body_done(&self) -> bool {
    method body_empty (line 256) | pub fn body_empty(&self) -> bool {
    method finish_body_buf (line 260) | fn finish_body_buf(&mut self, end_of_body: usize, total_read: usize) {
    method read_body (line 268) | pub async fn read_body<S>(&mut self, stream: &mut S) -> Result<Option<...
    method do_read_body (line 283) | pub async fn do_read_body<S>(&mut self, stream: &mut S) -> Result<Opti...
    method do_read_body_until_closed (line 337) | pub async fn do_read_body_until_closed<S>(&mut self, stream: &mut S) -...
    method do_read_chunked_body (line 365) | pub async fn do_read_chunked_body<S>(&mut self, stream: &mut S) -> Res...
    method parse_chunked_buf (line 514) | fn parse_chunked_buf(
    method do_read_chunked_body_final (line 635) | pub async fn do_read_chunked_body_final<S>(&mut self, stream: &mut S) ...
    method parse_trailers_end (line 746) | fn parse_trailers_end(
    method validate_crlf (line 824) | fn validate_crlf(
  type TrailersEndParseState (line 892) | pub enum TrailersEndParseState {
  type BodyMode (line 898) | pub enum BodyMode {
  type BM (line 906) | type BM = BodyMode;
  type BodyWriter (line 908) | pub struct BodyWriter {
    method new (line 913) | pub fn new() -> Self {
    method init_chunked (line 919) | pub fn init_chunked(&mut self) {
    method init_close_delimited (line 923) | pub fn init_close_delimited(&mut self) {
    method init_content_length (line 927) | pub fn init_content_length(&mut self, cl: usize) {
    method convert_to_close_delimited (line 931) | pub fn convert_to_close_delimited(&mut self) {
    method write_body (line 949) | pub async fn write_body<S>(&mut self, stream: &mut S, buf: &[u8]) -> R...
    method finished (line 963) | pub fn finished(&self) -> bool {
    method is_close_delimited (line 971) | pub fn is_close_delimited(&self) -> bool {
    method do_write_body (line 975) | async fn do_write_body<S>(&mut self, stream: &mut S, buf: &[u8]) -> Re...
    method do_write_chunked_body (line 1007) | async fn do_write_chunked_body<S>(
    method do_write_until_close_body (line 1033) | async fn do_write_until_close_body<S>(
    method finish (line 1057) | pub async fn finish<S>(&mut self, stream: &mut S) -> Result<Option<usi...
    method do_finish_body (line 1070) | fn do_finish_body<S>(&mut self, _stream: S) -> Result<Option<usize>> {
    method do_finish_chunked_body (line 1086) | async fn do_finish_chunked_body<S>(&mut self, stream: &mut S) -> Resul...
    method do_finish_until_close_body (line 1103) | fn do_finish_until_close_body<S>(&mut self, _stream: &mut S) -> Result...
  function init_log (line 1119) | fn init_log() {
  function read_with_body_content_length (line 1124) | async fn read_with_body_content_length() {
  function read_with_body_content_length_2 (line 1138) | async fn read_with_body_content_length_2() {
  function read_with_body_content_length_less (line 1157) | async fn read_with_body_content_length_less() {
  function read_with_body_content_length_more (line 1175) | async fn read_with_body_content_length_more() {
  function read_with_body_content_length_overread (line 1198) | async fn read_with_body_content_length_overread() {
  function read_with_body_content_length_rewind (line 1217) | async fn read_with_body_content_length_rewind() {
  function read_with_body_http10 (line 1236) | async fn read_with_body_http10() {
  function read_with_body_http10_rewind (line 1254) | async fn read_with_body_http10_rewind() {
  function read_with_body_zero_chunk (line 1277) | async fn read_with_body_zero_chunk() {
  function read_with_body_zero_chunk_malformed (line 1290) | async fn read_with_body_zero_chunk_malformed() {
  function read_with_body_zero_chunk_split (line 1308) | async fn read_with_body_zero_chunk_split() {
  function read_with_body_zero_chunk_split_head (line 1325) | async fn read_with_body_zero_chunk_split_head() {
  function read_with_body_zero_chunk_split_head_2 (line 1350) | async fn read_with_body_zero_chunk_split_head_2() {
  function read_with_body_zero_chunk_split_head_3 (line 1375) | async fn read_with_body_zero_chunk_split_head_3() {
  function read_with_body_chunk_ext (line 1406) | async fn read_with_body_chunk_ext() {
  function read_with_body_chunk_ext_oversize (line 1419) | async fn read_with_body_chunk_ext_oversize() {
  function read_with_body_1_chunk (line 1445) | async fn read_with_body_1_chunk() {
  function read_with_body_1_chunk_malformed (line 1463) | async fn read_with_body_1_chunk_malformed() {
  function read_with_body_1_chunk_partial_end (line 1478) | async fn read_with_body_1_chunk_partial_end() {
  function read_with_body_1_chunk_partial_end_1 (line 1499) | async fn read_with_body_1_chunk_partial_end_1() {
  function read_with_body_1_chunk_partial_end_2 (line 1528) | async fn read_with_body_1_chunk_partial_end_2() {
  function read_with_body_1_chunk_incomplete (line 1557) | async fn read_with_body_1_chunk_incomplete() {
  function read_with_body_1_chunk_partial_end_malformed (line 1573) | async fn read_with_body_1_chunk_partial_end_malformed() {
  function read_with_body_1_chunk_rewind (line 1591) | async fn read_with_body_1_chunk_rewind() {
  function read_with_body_multi_chunk (line 1614) | async fn read_with_body_multi_chunk() {
  function read_with_body_multi_chunk_malformed (line 1636) | async fn read_with_body_multi_chunk_malformed() {
  function read_with_body_partial_chunk (line 1665) | async fn read_with_body_partial_chunk() {
  function read_with_body_partial_chunk_end (line 1687) | async fn read_with_body_partial_chunk_end() {
  function read_with_body_partial_head_chunk (line 1710) | async fn read_with_body_partial_head_chunk() {
  function read_with_body_partial_head_terminal_crlf (line 1731) | async fn read_with_body_partial_head_terminal_crlf() {
  function read_with_body_partial_head_terminal_crlf_2 (line 1765) | async fn read_with_body_partial_head_terminal_crlf_2() {
  function read_with_body_partial_head_terminal_crlf_3 (line 1795) | async fn read_with_body_partial_head_terminal_crlf_3() {
  function read_with_body_partial_head_terminal_crlf_malformed (line 1840) | async fn read_with_body_partial_head_terminal_crlf_malformed() {
  function read_with_body_partial_head_terminal_crlf_overread (line 1873) | async fn read_with_body_partial_head_terminal_crlf_overread() {
  function read_with_body_multi_chunk_overread (line 1907) | async fn read_with_body_multi_chunk_overread() {
  function read_with_body_partial_head_chunk_incomplete (line 1929) | async fn read_with_body_partial_head_chunk_incomplete() {
  function read_with_body_trailers (line 1944) | async fn read_with_body_trailers() {
  function read_with_body_trailers_2 (line 2001) | async fn read_with_body_trailers_2() {
  function read_with_body_trailers_3 (line 2031) | async fn read_with_body_trailers_3() {
  function read_with_body_trailers_4 (line 2070) | async fn read_with_body_trailers_4() {
  function read_with_body_trailers_malformed (line 2112) | async fn read_with_body_trailers_malformed() {
  function read_with_body_trailers_malformed_2 (line 2139) | async fn read_with_body_trailers_malformed_2() {
  function read_with_body_trailers_malformed_3 (line 2170) | async fn read_with_body_trailers_malformed_3() {
  function read_with_body_trailers_overflow (line 2202) | async fn read_with_body_trailers_overflow() {
  function write_body_cl (line 2260) | async fn write_body_cl() {
  function write_body_chunked (line 2287) | async fn write_body_chunked() {
  function write_body_http10 (line 2322) | async fn write_body_http10() {

FILE: pingora-core/src/protocols/http/v1/client.rs
  type HttpSession (line 35) | pub struct HttpSession {
    method new (line 73) | pub fn new(stream: Stream) -> Self {
    method new_with_options (line 104) | pub fn new_with_options<P: crate::upstreams::peer::Peer>(stream: Strea...
    method write_request_header (line 117) | pub async fn write_request_header(&mut self, req: Box<RequestHeader>) ...
    method do_write_body (line 150) | async fn do_write_body(&mut self, buf: &[u8]) -> Result<Option<usize>> {
    method write_body (line 165) | pub async fn write_body(&mut self, buf: &[u8]) -> Result<Option<usize>> {
    method maybe_force_close_body_reader (line 176) | fn maybe_force_close_body_reader(&mut self) {
    method finish_body (line 185) | pub async fn finish_body(&mut self) -> Result<Option<usize>> {
    method validate_response (line 198) | fn validate_response(&self) -> Result<()> {
    method read_response (line 219) | pub async fn read_response(&mut self) -> Result<usize> {
    method read_resp_header_parts (line 396) | pub async fn read_resp_header_parts(&mut self) -> Result<Box<ResponseH...
    method resp_header (line 403) | pub fn resp_header(&self) -> Option<&ResponseHeader> {
    method get_header (line 411) | pub fn get_header(&self, name: impl AsHeaderName) -> Option<&HeaderVal...
    method get_header_bytes (line 418) | pub fn get_header_bytes(&self, name: impl AsHeaderName) -> &[u8] {
    method get_status (line 423) | pub fn get_status(&self) -> Option<StatusCode> {
    method do_read_body (line 427) | async fn do_read_body(&mut self) -> Result<Option<BufRef>> {
    method read_body_ref (line 437) | pub async fn read_body_ref(&mut self) -> Result<Option<&[u8]>> {
    method read_body_bytes (line 456) | pub async fn read_body_bytes(&mut self) -> Result<Option<Bytes>> {
    method body_bytes_received (line 462) | pub fn body_bytes_received(&self) -> usize {
    method is_body_done (line 467) | pub fn is_body_done(&mut self) -> bool {
    method set_allow_h1_response_invalid_content_length (line 472) | pub fn set_allow_h1_response_invalid_content_length(&mut self, allow: ...
    method get_headers_raw (line 476) | pub(super) fn get_headers_raw(&self) -> &[u8] {
    method get_headers_raw_bytes (line 482) | pub fn get_headers_raw_bytes(&self) -> Bytes {
    method set_keepalive (line 486) | fn set_keepalive(&mut self, seconds: Option<u64>) {
    method respect_keepalive (line 504) | pub fn respect_keepalive(&mut self) {
    method will_keepalive (line 554) | pub fn will_keepalive(&self) -> bool {
    method is_connection_keepalive (line 558) | fn is_connection_keepalive(&self) -> Option<bool> {
    method get_keepalive_values (line 575) | fn get_keepalive_values(&self) -> (Option<u64>, Option<usize>) {
    method shutdown (line 601) | pub async fn shutdown(&mut self) {
    method reuse (line 610) | pub async fn reuse(mut self) -> Option<Stream> {
    method init_body_reader (line 623) | fn init_body_reader(&mut self) {
    method is_upgrade_req (line 669) | pub fn is_upgrade_req(&self) -> bool {
    method is_upgrade (line 679) | fn is_upgrade(&self, header: &ResponseHeader) -> Option<bool> {
    method was_upgraded (line 691) | pub fn was_upgraded(&self) -> bool {
    method maybe_upgrade_body_writer (line 697) | pub fn maybe_upgrade_body_writer(&mut self) {
    method get_content_length (line 704) | fn get_content_length(&self) -> Result<Option<usize>> {
    method is_chunked_encoding (line 711) | fn is_chunked_encoding(&self) -> bool {
    method init_req_body_writer (line 717) | fn init_req_body_writer(&mut self, header: &RequestHeader) {
    method init_body_writer_comm (line 721) | fn init_body_writer_comm(&mut self, headers: &HMap) {
    method should_read_resp_header (line 744) | fn should_read_resp_header(&self) -> bool {
    method read_response_task (line 753) | pub async fn read_response_task(&mut self) -> Result<HttpTask> {
    method digest (line 789) | pub fn digest(&self) -> &Digest {
    method digest_mut (line 794) | pub fn digest_mut(&mut self) -> &mut Digest {
    method server_addr (line 799) | pub fn server_addr(&self) -> Option<&SocketAddr> {
    method client_addr (line 807) | pub fn client_addr(&self) -> Option<&SocketAddr> {
    method stream (line 815) | pub fn stream(&self) -> &Stream {
    method into_inner (line 822) | pub fn into_inner(self) -> Stream {
  function parse_resp_buffer (line 828) | fn parse_resp_buffer<'buf>(
  function http_req_header_to_wire (line 849) | pub fn http_req_header_to_wire(req: &RequestHeader) -> Option<BytesMut> {
  method id (line 878) | fn id(&self) -> UniqueIDType {
  function init_log (line 892) | fn init_log() {
  function read_basic_response (line 897) | async fn read_basic_response() {
  function read_response_custom_reason (line 908) | async fn read_response_custom_reason() {
  function read_response_default (line 922) | async fn read_response_default() {
  function body_bytes_received_content_length (line 947) | async fn body_bytes_received_content_length() {
  function body_bytes_received_chunked (line 965) | async fn body_bytes_received_chunked() {
  function h1_body_bytes_received_http10_until_close (line 984) | async fn h1_body_bytes_received_http10_until_close() {
  function h1_body_bytes_received_chunked_multi (line 1002) | async fn h1_body_bytes_received_chunked_multi() {
  function h1_body_bytes_received_preread_in_header_buf (line 1021) | async fn h1_body_bytes_received_preread_in_header_buf() {
  function h1_body_bytes_received_overread_content_length (line 1038) | async fn h1_body_bytes_received_overread_content_length() {
  function h1_body_bytes_received_after_100_continue (line 1058) | async fn h1_body_bytes_received_after_100_continue() {
  function read_response_overread (line 1093) | async fn read_response_overread() {
  function read_resp_header_with_space (line 1117) | async fn read_resp_header_with_space() {
  function read_resp_header_with_utf8 (line 1130) | async fn read_resp_header_with_utf8() {
  function read_timeout (line 1143) | async fn read_timeout() {
  function read_2_buf (line 1157) | async fn read_2_buf() {
  function read_invalid (line 1178) | async fn read_invalid() {
  function write (line 1188) | async fn write() {
  function validate_response_rejects_invalid_content_length (line 1209) | async fn validate_response_rejects_invalid_content_length(#[case] invali...
  function allow_invalid_content_length_close_delimited_when_configured (line 1224) | async fn allow_invalid_content_length_close_delimited_when_configured() {
  function validate_response_accepts_valid_content_length (line 1259) | async fn validate_response_accepts_valid_content_length(#[case] valid_va...
  function validate_response_accepts_no_content_length (line 1272) | async fn validate_response_accepts_no_content_length() {
  function response_transfer_encoding_and_content_length_handling (line 1292) | async fn response_transfer_encoding_and_content_length_handling(
  function write_timeout (line 1335) | async fn write_timeout() {
  function write_body_timeout (line 1353) | async fn write_body_timeout() {
  function write_invalid_path (line 1377) | async fn write_invalid_path() {
  function read_informational (line 1391) | async fn read_informational() {
  function read_informational_combined_with_final (line 1423) | async fn read_informational_combined_with_final() {
  function read_informational_multiple_combined_with_final (line 1466) | async fn read_informational_multiple_combined_with_final() {
  function read_informational_then_keepalive_response (line 1510) | async fn read_informational_then_keepalive_response() {
  function init_body_for_upgraded_req (line 1578) | async fn init_body_for_upgraded_req() {
  function init_preread_body_for_upgraded_req (line 1643) | async fn init_preread_body_for_upgraded_req() {
  function read_body_eos_after_upgrade (line 1706) | async fn read_body_eos_after_upgrade() {
  function read_switching_protocol (line 1783) | async fn read_switching_protocol() {
  function read_obsolete_multiline_headers (line 1851) | async fn read_obsolete_multiline_headers() {
  function read_headers_skip_invalid_line (line 1879) | async fn read_headers_skip_invalid_line() {
  function read_keepalive_headers (line 1891) | async fn read_keepalive_headers() {
  function test_http10_response_with_transfer_encoding_disables_keepalive (line 2042) | async fn test_http10_response_with_transfer_encoding_disables_keepalive() {
  function test_http11_response_with_transfer_encoding_allows_keepalive (line 2063) | async fn test_http11_response_with_transfer_encoding_allows_keepalive() {
  function test_response_multiple_transfer_encoding_headers (line 2082) | async fn test_response_multiple_transfer_encoding_headers() {
  function test_response_multiple_te_headers_chunked_not_last (line 2108) | async fn test_response_multiple_te_headers_chunked_not_last() {
  function test_is_chunked_encoding_before_response (line 2127) | fn test_is_chunked_encoding_before_response() {
  function write_request_body_implicit_zero_content_length (line 2137) | async fn write_request_body_implicit_zero_content_length() {
  function write_request_body_with_content_length (line 2156) | async fn write_request_body_with_content_length() {
  function close_delimited_response_explicitly_disables_keepalive (line 2183) | async fn close_delimited_response_explicitly_disables_keepalive() {
  function test_request_to_wire (line 2235) | fn test_request_to_wire() {

FILE: pingora-core/src/protocols/http/v1/common.rs
  constant MAX_HEADERS (line 27) | pub(super) const MAX_HEADERS: usize = 256;
  constant INIT_HEADER_BUF_SIZE (line 29) | pub(super) const INIT_HEADER_BUF_SIZE: usize = 4096;
  constant MAX_HEADER_SIZE (line 30) | pub(super) const MAX_HEADER_SIZE: usize = 1048575;
  constant BODY_BUF_LIMIT (line 32) | pub(crate) const BODY_BUF_LIMIT: usize = 1024 * 64;
  constant CRLF (line 34) | pub const CRLF: &[u8; 2] = b"\r\n";
  constant HEADER_KV_DELIMITER (line 35) | pub const HEADER_KV_DELIMITER: &[u8; 2] = b": ";
  type HeaderParseState (line 37) | pub(super) enum HeaderParseState {
  type KeepaliveStatus (line 44) | pub(super) enum KeepaliveStatus {
  type ConnectionValue (line 50) | struct ConnectionValue {
    method new (line 57) | fn new() -> Self {
    method close (line 65) | fn close(mut self) -> Self {
    method upgrade (line 69) | fn upgrade(mut self) -> Self {
    method keep_alive (line 73) | fn keep_alive(mut self) -> Self {
  function parse_connection_header (line 79) | fn parse_connection_header(value: &[u8]) -> ConnectionValue {
  function init_body_writer_comm (line 123) | pub(crate) fn init_body_writer_comm(body_writer: &mut BodyWriter, header...
  function find_last_te_token (line 145) | fn find_last_te_token(bytes: &[u8]) -> &[u8] {
  function is_chunked_encoding_from_headers (line 156) | pub(crate) fn is_chunked_encoding_from_headers(headers: &HMap) -> bool {
  function is_upgrade_req (line 178) | pub fn is_upgrade_req(req: &RequestHeader) -> bool {
  function is_expect_continue_req (line 182) | pub fn is_expect_continue_req(req: &RequestHeader) -> bool {
  function is_upgrade_resp (line 194) | pub fn is_upgrade_resp(header: &ResponseHeader) -> bool {
  function header_value_content_length (line 199) | pub fn header_value_content_length(
  function buf_to_content_length (line 209) | pub(super) fn buf_to_content_length(header_value: Option<&[u8]>) -> Resu...
  function is_buf_keepalive (line 245) | pub(super) fn is_buf_keepalive(header_value: Option<&HeaderValue>) -> Op...
  function populate_headers (line 259) | pub(super) fn populate_headers(
  function check_dup_content_length (line 285) | pub(super) fn check_dup_content_length(headers: &HMap) -> Result<()> {
  function test_check_dup_content_length (line 315) | fn test_check_dup_content_length() {
  function test_is_upgrade_resp (line 331) | fn test_is_upgrade_resp() {
  function test_is_chunked_encoding_from_headers_empty (line 351) | fn test_is_chunked_encoding_from_headers_empty() {
  function test_is_chunked_encoding_single_header (line 366) | fn test_is_chunked_encoding_single_header(#[case] value: &str, #[case] e...
  function test_is_chunked_encoding_multiple_headers (line 382) | fn test_is_chunked_encoding_multiple_headers(#[case] values: &[&str], #[...

FILE: pingora-core/src/protocols/http/v1/server.rs
  type HttpSession (line 40) | pub struct HttpSession {
    method new (line 95) | pub fn new(underlying_stream: Stream) -> Self {
    method read_request (line 135) | pub async fn read_request(&mut self) -> Result<Option<usize>> {
    method validate_request (line 328) | pub fn validate_request(&self) -> Result<()> {
    method req_header (line 359) | pub fn req_header(&self) -> &RequestHeader {
    method req_header_mut (line 368) | pub fn req_header_mut(&mut self) -> &mut RequestHeader {
    method get_header (line 377) | pub fn get_header(&self, name: impl AsHeaderName) -> Option<&HeaderVal...
    method get_method (line 384) | pub(crate) fn get_method(&self) -> Option<&http::Method> {
    method get_path (line 390) | pub(crate) fn get_path(&self) -> &[u8] {
    method get_host (line 395) | pub(crate) fn get_host(&self) -> &[u8] {
    method request_summary (line 403) | pub fn request_summary(&self) -> String {
    method is_upgrade_req (line 413) | pub fn is_upgrade_req(&self) -> bool {
    method get_header_bytes (line 421) | pub fn get_header_bytes(&self, name: impl AsHeaderName) -> &[u8] {
    method read_body_bytes (line 426) | pub async fn read_body_bytes(&mut self) -> Result<Option<Bytes>> {
    method do_read_body (line 438) | async fn do_read_body(&mut self) -> Result<Option<BufRef>> {
    method read_body (line 446) | async fn read_body(&mut self) -> Result<Option<BufRef>> {
    method do_drain_request_body (line 456) | async fn do_drain_request_body(&mut self) -> Result<()> {
    method drain_request_body (line 467) | pub async fn drain_request_body(&mut self) -> Result<()> {
    method is_body_done (line 481) | pub fn is_body_done(&mut self) -> bool {
    method is_body_empty (line 490) | pub fn is_body_empty(&mut self) -> bool {
    method write_response_header (line 497) | pub async fn write_response_header(&mut self, mut header: Box<Response...
    method response_written (line 611) | pub fn response_written(&self) -> Option<&ResponseHeader> {
    method is_upgrade (line 618) | pub fn is_upgrade(&self, header: &ResponseHeader) -> Option<bool> {
    method was_upgraded (line 630) | pub fn was_upgraded(&self) -> bool {
    method set_keepalive (line 634) | fn set_keepalive(&mut self, seconds: Option<u64>) {
    method get_keepalive_timeout (line 649) | pub fn get_keepalive_timeout(&self) -> Option<u64> {
    method set_keepalive_reuses_remaining (line 657) | pub fn set_keepalive_reuses_remaining(&mut self, remaining: Option<u32...
    method get_keepalive_reuses_remaining (line 661) | pub fn get_keepalive_reuses_remaining(&self) -> Option<u32> {
    method will_keepalive (line 666) | pub fn will_keepalive(&self) -> bool {
    method get_keepalive_values (line 674) | fn get_keepalive_values(&self) -> (Option<u64>, Option<usize>) {
    method ignore_info_resp (line 679) | fn ignore_info_resp(&self, status: u16) -> bool {
    method is_expect_continue_req (line 684) | fn is_expect_continue_req(&self) -> bool {
    method is_connection_keepalive (line 691) | fn is_connection_keepalive(&self) -> Option<bool> {
    method write_timeout (line 696) | fn write_timeout(&self, buf_len: usize) -> Option<Duration> {
    method respect_keepalive (line 710) | pub fn respect_keepalive(&mut self) {
    method init_body_writer (line 729) | fn init_body_writer(&mut self, header: &ResponseHeader) {
    method write_response_header_ref (line 754) | pub async fn write_response_header_ref(&mut self, resp: &ResponseHeade...
    method do_write_body (line 758) | async fn do_write_body(&mut self, buf: &[u8]) -> Result<Option<usize>> {
    method write_body (line 773) | pub async fn write_body(&mut self, buf: &[u8]) -> Result<Option<usize>> {
    method do_write_body_buf (line 784) | async fn do_write_body_buf(&mut self) -> Result<Option<usize>> {
    method write_body_buf (line 805) | async fn write_body_buf(&mut self) -> Result<Option<usize>> {
    method maybe_force_close_body_reader (line 815) | fn maybe_force_close_body_reader(&mut self) {
    method finish_body (line 826) | pub async fn finish_body(&mut self) -> Result<Option<usize>> {
    method body_bytes_sent (line 842) | pub fn body_bytes_sent(&self) -> usize {
    method body_bytes_read (line 847) | pub fn body_bytes_read(&self) -> usize {
    method is_chunked_encoding (line 851) | fn is_chunked_encoding(&self) -> bool {
    method get_content_length (line 855) | fn get_content_length(&self) -> Result<Option<usize>> {
    method init_body_reader (line 862) | fn init_body_reader(&mut self) {
    method retry_buffer_truncated (line 899) | pub fn retry_buffer_truncated(&self) -> bool {
    method enable_retry_buffering (line 905) | pub fn enable_retry_buffering(&mut self) {
    method get_retry_buffer (line 911) | pub fn get_retry_buffer(&self) -> Option<Bytes> {
    method get_body (line 921) | fn get_body(&self, buf_ref: &BufRef) -> &[u8] {
    method idle (line 927) | pub async fn idle(&mut self) -> Result<usize> {
    method read_body_or_idle (line 940) | pub async fn read_body_or_idle(&mut self, no_body_expected: bool) -> R...
    method get_headers_raw_bytes (line 962) | pub fn get_headers_raw_bytes(&self) -> Bytes {
    method shutdown (line 968) | pub async fn shutdown(&mut self) {
    method set_server_keepalive (line 977) | pub fn set_server_keepalive(&mut self, keepalive: Option<u64>) {
    method set_read_timeout (line 988) | pub fn set_read_timeout(&mut self, timeout: Option<Duration>) {
    method get_read_timeout (line 993) | pub fn get_read_timeout(&self) -> Option<Duration> {
    method set_write_timeout (line 1000) | pub fn set_write_timeout(&mut self, timeout: Option<Duration>) {
    method get_write_timeout (line 1005) | pub fn get_write_timeout(&self) -> Option<Duration> {
    method set_total_drain_timeout (line 1017) | pub fn set_total_drain_timeout(&mut self, timeout: Option<Duration>) {
    method get_total_drain_timeout (line 1022) | pub fn get_total_drain_timeout(&self) -> Option<Duration> {
    method set_min_send_rate (line 1034) | pub fn set_min_send_rate(&mut self, min_send_rate: Option<usize>) {
    method set_ignore_info_resp (line 1046) | pub fn set_ignore_info_resp(&mut self, ignore: bool) {
    method set_close_on_response_before_downstream_finish (line 1054) | pub fn set_close_on_response_before_downstream_finish(&mut self, close...
    method digest (line 1059) | pub fn digest(&self) -> &Digest {
    method digest_mut (line 1064) | pub fn digest_mut(&mut self) -> &mut Digest {
    method client_addr (line 1069) | pub fn client_addr(&self) -> Option<&SocketAddr> {
    method server_addr (line 1077) | pub fn server_addr(&self) -> Option<&SocketAddr> {
    method reuse (line 1093) | pub async fn reuse(mut self) -> Result<Option<Stream>> {
    method write_continue_response (line 1115) | pub async fn write_continue_response(&mut self) -> Result<()> {
    method write_non_empty_body (line 1126) | async fn write_non_empty_body(&mut self, data: Option<Bytes>, upgraded...
    method response_duplex (line 1148) | async fn response_duplex(&mut self, task: HttpTask) -> Result<bool> {
    method buffer_body_data (line 1175) | fn buffer_body_data(&mut self, data: Option<Bytes>, upgraded: bool) {
    method response_duplex_vec (line 1193) | pub async fn response_duplex_vec(&mut self, mut tasks: Vec<HttpTask>) ...
    method stream (line 1239) | pub fn stream(&self) -> &Stream {
    method into_inner (line 1246) | pub fn into_inner(self) -> Stream {
  constant URI_ESC_CHARSET (line 1257) | const URI_ESC_CHARSET: &AsciiSet = &CONTROLS.add(b' ').add(b'<').add(b'>...
  function escape_illegal_request_line (line 1259) | fn escape_illegal_request_line(buf: &BytesMut) -> Option<BytesMut> {
  function parse_req_buffer (line 1291) | fn parse_req_buffer<'buf>(
  function http_resp_header_to_buf (line 1320) | fn http_resp_header_to_buf(
  function init_log (line 1361) | fn init_log() {
  function read_basic (line 1366) | async fn read_basic() {
  function read_invalid_path (line 1378) | async fn read_invalid_path() {
  function read_2_buf (line 1390) | async fn read_2_buf() {
  function read_with_body_content_length (line 1411) | async fn read_with_body_content_length() {
  function read_with_body_timeout (line 1431) | async fn read_with_body_timeout() {
  function read_with_body_content_length_single_read (line 1451) | async fn read_with_body_content_length_single_read() {
  function read_with_body_http10 (line 1466) | async fn read_with_body_http10() {
  function read_with_body_http10_single_read (line 1487) | async fn read_with_body_http10_single_read() {
  function read_http11_default_no_body (line 1503) | async fn read_http11_default_no_body() {
  function read_http10_with_content_length (line 1517) | async fn read_http10_with_content_length() {
  function read_with_body_chunked_0_incomplete (line 1536) | async fn read_with_body_chunked_0_incomplete() {
  function read_with_body_chunked_0_extra (line 1557) | async fn read_with_body_chunked_0_extra() {
  function read_with_body_chunked_single_read (line 1582) | async fn read_with_body_chunked_single_read() {
  function read_with_body_chunked_single_read_extra (line 1608) | async fn read_with_body_chunked_single_read_extra() {
  function transfer_encoding_and_content_length_disallowed (line 1644) | async fn transfer_encoding_and_content_length_disallowed(
  function validate_request_rejects_invalid_content_length (line 1691) | async fn validate_request_rejects_invalid_content_length(#[case] invalid...
  function validate_request_accepts_valid_content_length (line 1710) | async fn validate_request_accepts_valid_content_length(#[case] valid_val...
  function validate_request_accepts_no_content_length (line 1723) | async fn validate_request_accepts_no_content_length() {
  function read_invalid (line 1734) | async fn read_invalid() {
  function read_invalid_header_end (line 1744) | async fn read_invalid_header_end() {
  function build_upgrade_req (line 1752) | async fn build_upgrade_req(upgrade: &str, conn: &str) -> HttpSession {
  function read_upgrade_req (line 1761) | async fn read_upgrade_req() {
  constant POST_CL_UPGRADE_REQ (line 1800) | const POST_CL_UPGRADE_REQ: &[u8] = b"POST / HTTP/1.1\r\nHost: pingora.or...
  constant POST_BODY_DATA (line 1801) | const POST_BODY_DATA: &[u8] = b"abcdefghij";
  constant POST_CHUNKED_UPGRADE_REQ (line 1802) | const POST_CHUNKED_UPGRADE_REQ: &[u8] = b"POST / HTTP/1.1\r\nHost: pingo...
  constant POST_BODY_DATA_CHUNKED (line 1803) | const POST_BODY_DATA_CHUNKED: &[u8] = b"3\r\nabc\r\n7\r\ndefghij\r\n0\r\...
  function read_upgrade_req_with_body (line 1809) | async fn read_upgrade_req_with_body(
  function read_upgrade_req_with_body_extra (line 1860) | async fn read_upgrade_req_with_body_extra(
  function read_upgrade_req_with_preread_body (line 1911) | async fn read_upgrade_req_with_preread_body(
  function read_upgrade_req_with_preread_body_after_101 (line 1961) | async fn read_upgrade_req_with_preread_body_after_101(
  function read_upgrade_req_with_1xx_response (line 1997) | async fn read_upgrade_req_with_1xx_response() {
  function test_upgrade_without_content_length_with_ws_data (line 2031) | async fn test_upgrade_without_content_length_with_ws_data() {
  function set_server_keepalive (line 2071) | async fn set_server_keepalive() {
  function write (line 2113) | async fn write() {
  function write_custom_reason (line 2129) | async fn write_custom_reason() {
  function write_informational (line 2146) | async fn write_informational() {
  function write_informational_ignored (line 2167) | async fn write_informational_ignored() {
  function write_informational_100_not_ignored_if_expect_continue (line 2190) | async fn write_informational_100_not_ignored_if_expect_continue() {
  function write_informational_1xx_ignored_if_expect_continue (line 2214) | async fn write_informational_1xx_ignored_if_expect_continue() {
  function write_101_switching_protocol (line 2238) | async fn write_101_switching_protocol() {
  function write_body_cl (line 2271) | async fn write_body_cl() {
  function write_body_http10 (line 2300) | async fn write_body_http10() {
  function write_body_chunk (line 2325) | async fn write_body_chunk() {
  function read_with_illegal (line 2358) | async fn read_with_illegal() {
  function escape_illegal (line 2378) | fn escape_illegal() {
  function test_write_body_buf (line 2407) | async fn test_write_body_buf() {
  function test_write_body_buf_write_timeout (line 2426) | async fn test_write_body_buf_write_timeout() {
  function test_write_continue_resp (line 2452) | async fn test_write_continue_resp() {
  function test_get_write_timeout (line 2462) | fn test_get_write_timeout() {
  function test_get_write_timeout_none (line 2471) | fn test_get_write_timeout_none() {
  function test_get_write_timeout_min_send_rate_zero (line 2477) | fn test_get_write_timeout_min_send_rate_zero() {
  function test_get_write_timeout_min_send_rate_overrides_write_timeout (line 2488) | fn test_get_write_timeout_min_send_rate_overrides_write_timeout() {
  function test_get_write_timeout_min_send_rate_max_zero_buf (line 2499) | fn test_get_write_timeout_min_send_rate_max_zero_buf() {
  function test_te_and_cl_disables_keepalive (line 2508) | async fn test_te_and_cl_disables_keepalive() {
  function test_http10_request_with_transfer_encoding_rejected (line 2542) | async fn test_http10_request_with_transfer_encoding_rejected() {
  function test_http10_request_without_transfer_encoding_accepted (line 2564) | async fn test_http10_request_without_transfer_encoding_accepted() {
  function test_http11_request_with_transfer_encoding_accepted (line 2581) | async fn test_http11_request_with_transfer_encoding_accepted() {
  function test_request_multiple_transfer_encoding_headers (line 2601) | async fn test_request_multiple_transfer_encoding_headers() {
  function test_request_multiple_te_headers_chunked_not_last (line 2627) | async fn test_request_multiple_te_headers_chunked_not_last() {
  function test_no_more_reuses_explicitly_disables_reuse (line 2645) | async fn test_no_more_reuses_explicitly_disables_reuse() {
  function test_close_delimited_response_explicitly_disables_reuse (line 2678) | async fn test_close_delimited_response_explicitly_disables_reuse() {
  function init_log (line 2712) | fn init_log() {
  function test_response_to_wire (line 2717) | fn test_response_to_wire() {
  constant TEST_MAX_WAIT_FOR_READ (line 2746) | const TEST_MAX_WAIT_FOR_READ: Duration = Duration::from_secs(3);
  constant TEST_FOREVER_DURATION (line 2749) | const TEST_FOREVER_DURATION: Duration = Duration::from_secs(600);
  constant TEST_READ_TIMEOUT (line 2752) | const TEST_READ_TIMEOUT: Duration = Duration::from_secs(1);
  type ReadBlockedForeverError (line 2755) | struct ReadBlockedForeverError;
  function mocked_blocking_headers_forever_stream (line 2758) | fn mocked_blocking_headers_forever_stream() -> Box<Mock> {
  function mocked_blocking_body_forever_stream (line 2762) | fn mocked_blocking_body_forever_stream() -> Box<Mock> {
  function test_read_with_tokio_timeout (line 2776) | async fn test_read_with_tokio_timeout<F, T>(
  function test_read_http_request_headers_timeout_for_read_request (line 2787) | async fn test_read_http_request_headers_timeout_for_read_request() {
  function test_read_http_body_timeout_for_read_body_bytes (line 2803) | async fn test_read_http_body_timeout_for_read_body_bytes() {
  function init_log (line 2827) | fn init_log() {
  function test_reuse_with_preread_body_overread (line 2844) | async fn test_reuse_with_preread_body_overread(
  function test_reuse_with_chunked_body_overread (line 2901) | async fn test_reuse_with_chunked_body_overread(#[case] read_body: bool) {

FILE: pingora-core/src/protocols/http/v2/client.rs
  constant PING_TIMEDOUT (line 38) | pub const PING_TIMEDOUT: ErrorType = ErrorType::new("PingTimedout");
  type Http2Session (line 40) | pub struct Http2Session {
    method new (line 69) | pub(crate) fn new(send_req: SendRequest<Bytes>, conn: ConnectionRef) -...
    method sanitize_request_header (line 85) | fn sanitize_request_header(req: &mut RequestHeader) -> Result<()> {
    method write_request_header (line 112) | pub fn write_request_header(&mut self, mut req: Box<RequestHeader>, en...
    method write_request_body (line 135) | pub async fn write_request_body(&mut self, data: Bytes, end: bool) -> ...
    method finish_request_body (line 154) | pub fn finish_request_body(&mut self) -> Result<()> {
    method read_response_header (line 174) | pub async fn read_response_header(&mut self) -> Result<()> {
    method poll_read_response_header (line 201) | pub fn poll_read_response_header(
    method read_response_body (line 232) | pub async fn read_response_body(&mut self) -> Result<Option<Bytes>> {
    method poll_read_response_body (line 269) | pub fn poll_read_response_body(
    method response_finished (line 293) | pub fn response_finished(&self) -> bool {
    method check_response_end_or_error (line 303) | pub fn check_response_end_or_error(&mut self) -> Result<bool> {
    method read_trailers (line 339) | pub async fn read_trailers(&mut self) -> Result<Option<HeaderMap>> {
    method request_header (line 379) | pub fn request_header(&self) -> Option<&RequestHeader> {
    method response_header (line 384) | pub fn response_header(&self) -> Option<&ResponseHeader> {
    method shutdown (line 389) | pub fn shutdown(&mut self) {
    method conn (line 400) | pub(crate) fn conn(&self) -> ConnectionRef {
    method ping_timedout (line 407) | pub(crate) fn ping_timedout(&self) -> bool {
    method digest (line 415) | pub fn digest(&self) -> Option<&Digest> {
    method digest_mut (line 422) | pub fn digest_mut(&mut self) -> Option<&mut Digest> {
    method server_addr (line 427) | pub fn server_addr(&self) -> Option<&SocketAddr> {
    method client_addr (line 436) | pub fn client_addr(&self) -> Option<&SocketAddr> {
    method fd (line 445) | pub fn fd(&self) -> UniqueIDType {
    method body_bytes_received (line 450) | pub fn body_bytes_received(&self) -> usize {
    method take_request_body_writer (line 455) | pub fn take_request_body_writer(&mut self) -> Option<SendStream<Bytes>> {
    method handle_err (line 459) | fn handle_err(&self, mut e: Box<Error>) -> Box<Error> {
  method drop (line 63) | fn drop(&mut self) {
  function handle_read_header_error (line 490) | fn handle_read_header_error(e: h2::Error) -> Box<Error> {
  function drive_connection (line 538) | pub async fn drive_connection<S>(
  constant PING_TIMEOUT (line 587) | const PING_TIMEOUT: Duration = Duration::from_secs(5);
  function do_ping_pong (line 589) | async fn do_ping_pong(
  function h2_body_bytes_received_multi_frames (line 637) | async fn h2_body_bytes_received_multi_frames() {

FILE: pingora-core/src/protocols/http/v2/mod.rs
  function reserve_and_send (line 28) | async fn reserve_and_send(
  function write_body (line 52) | pub async fn write_body(
  function test_client_write_timeout (line 107) | async fn test_client_write_timeout() {
  function test_server_write_timeout (line 187) | async fn test_server_write_timeout() {

FILE: pingora-core/src/protocols/http/v2/server.rs
  constant BODY_BUF_LIMIT (line 39) | const BODY_BUF_LIMIT: usize = 1024 * 64;
  type H2Connection (line 41) | type H2Connection<S> = server::Connection<S, Bytes>;
  function handshake (line 49) | pub async fn handshake(io: Stream, options: Option<H2Options>) -> Result...
  type Idle (line 72) | pub struct Idle<'a>(&'a mut HttpSession);
  type Output (line 75) | type Output = Result<h2::Reason>;
  method poll (line 77) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type HttpSession (line 88) | pub struct HttpSession {
    method from_h2_conn (line 128) | pub async fn from_h2_conn(
    method req_header (line 161) | pub fn req_header(&self) -> &RequestHeader {
    method req_header_mut (line 169) | pub fn req_header_mut(&mut self) -> &mut RequestHeader {
    method read_body_bytes (line 174) | pub async fn read_body_bytes(&mut self) -> Result<Option<Bytes>> {
    method poll_read_body_bytes (line 194) | pub fn poll_read_body_bytes(
    method do_drain_request_body (line 214) | async fn do_drain_request_body(&mut self) -> Result<()> {
    method drain_request_body (line 226) | pub async fn drain_request_body(&mut self) -> Result<()> {
    method set_write_timeout (line 244) | pub fn set_write_timeout(&mut self, timeout: Option<Duration>) {
    method get_write_timeout (line 249) | pub fn get_write_timeout(&self) -> Option<Duration> {
    method set_total_drain_timeout (line 255) | pub fn set_total_drain_timeout(&mut self, timeout: Option<Duration>) {
    method get_total_drain_timeout (line 260) | pub fn get_total_drain_timeout(&self) -> Option<Duration> {
    method write_response_header (line 271) | pub fn write_response_header(
    method write_body (line 318) | pub async fn write_body(&mut self, data: Bytes, end: bool) -> Result<(...
    method do_write_body (line 331) | async fn do_write_body(&mut self, data: Bytes, end: bool) -> Result<()> {
    method write_trailers (line 354) | pub fn write_trailers(&mut self, trailers: HeaderMap) -> Result<()> {
    method write_response_header_ref (line 375) | pub fn write_response_header_ref(&mut self, header: &ResponseHeader, e...
    method finish (line 386) | pub fn finish(&mut self) -> Result<()> {
    method response_duplex_vec (line 405) | pub async fn response_duplex_vec(&mut self, tasks: Vec<HttpTask>) -> R...
    method request_summary (line 454) | pub fn request_summary(&self) -> String {
    method response_written (line 474) | pub fn response_written(&self) -> Option<&ResponseHeader> {
    method shutdown (line 481) | pub fn shutdown(&mut self) {
    method take_response_body_writer (line 488) | pub fn take_response_body_writer(&mut self) -> Option<SendStream<Bytes...
    method pseudo_raw_h1_request_header (line 494) | pub fn pseudo_raw_h1_request_header(&self) -> Bytes {
    method is_body_done (line 500) | pub fn is_body_done(&self) -> bool {
    method is_body_empty (line 507) | pub fn is_body_empty(&self) -> bool {
    method retry_buffer_truncated (line 517) | pub fn retry_buffer_truncated(&self) -> bool {
    method enable_retry_buffering (line 523) | pub fn enable_retry_buffering(&mut self) {
    method get_retry_buffer (line 529) | pub fn get_retry_buffer(&self) -> Option<Bytes> {
    method idle (line 543) | pub fn idle(&mut self) -> Idle<'_> {
    method read_body_or_idle (line 549) | pub async fn read_body_or_idle(&mut self, no_body_expected: bool) -> R...
    method body_bytes_sent (line 562) | pub fn body_bytes_sent(&self) -> usize {
    method body_bytes_read (line 567) | pub fn body_bytes_read(&self) -> usize {
    method digest (line 572) | pub fn digest(&self) -> Option<&Digest> {
    method digest_mut (line 577) | pub fn digest_mut(&mut self) -> Option<&mut Digest> {
    method server_addr (line 582) | pub fn server_addr(&self) -> Option<&SocketAddr> {
    method client_addr (line 587) | pub fn client_addr(&self) -> Option<&SocketAddr> {
  function test_server_handshake_accept_request (line 599) | async fn test_server_handshake_accept_request() {
  function test_req_content_length_eq_0_and_no_header_eos (line 695) | async fn test_req_content_length_eq_0_and_no_header_eos() {
  function test_req_header_no_eos_empty_data_with_eos (line 768) | async fn test_req_header_no_eos_empty_data_with_eos() {

FILE: pingora-core/src/protocols/l4/ext.rs
  type TCP_INFO (line 41) | pub struct TCP_INFO {
    method new (line 102) | pub unsafe fn new() -> Self {
    method len (line 108) | pub fn len() -> socklen_t {
    method len (line 114) | pub fn len() -> usize {
  function set_opt (line 120) | fn set_opt<T: Copy>(sock: c_int, opt: c_int, val: c_int, payload: T) -> ...
  function get_opt (line 135) | fn get_opt<T>(
  function get_opt_sized (line 150) | fn get_opt_sized<T>(sock: c_int, opt: c_int, val: c_int) -> io::Result<T> {
  function cvt_linux_error (line 165) | fn cvt_linux_error(t: i32) -> io::Result<i32> {
  function ip_bind_addr_no_port (line 174) | fn ip_bind_addr_no_port(fd: RawFd, val: bool) -> io::Result<()> {
  function ip_bind_addr_no_port (line 184) | fn ip_bind_addr_no_port(_fd: RawFd, _val: bool) -> io::Result<()> {
  function ip_local_port_range (line 192) | fn ip_local_port_range(fd: RawFd, low: u16, high: u16) -> io::Result<()> {
  function ip_local_port_range (line 204) | fn ip_local_port_range(_fd: RawFd, _low: u16, _high: u16) -> io::Result<...
  function ip_local_port_range (line 209) | fn ip_local_port_range(_fd: RawSocket, _low: u16, _high: u16) -> io::Res...
  function set_so_keepalive (line 214) | fn set_so_keepalive(fd: RawFd, val: bool) -> io::Result<()> {
  function set_so_keepalive_idle (line 219) | fn set_so_keepalive_idle(fd: RawFd, val: Duration) -> io::Result<()> {
  function set_so_keepalive_user_timeout (line 229) | fn set_so_keepalive_user_timeout(fd: RawFd, val: Duration) -> io::Result...
  function set_so_keepalive_interval (line 239) | fn set_so_keepalive_interval(fd: RawFd, val: Duration) -> io::Result<()> {
  function set_so_keepalive_count (line 249) | fn set_so_keepalive_count(fd: RawFd, val: usize) -> io::Result<()> {
  function set_keepalive (line 254) | fn set_keepalive(fd: RawFd, ka: &TcpKeepalive) -> io::Result<()> {
  function set_keepalive (line 263) | fn set_keepalive(_fd: RawFd, _ka: &TcpKeepalive) -> io::Result<()> {
  function set_keepalive (line 268) | fn set_keepalive(_sock: RawSocket, _ka: &TcpKeepalive) -> io::Result<()> {
  function get_tcp_info (line 274) | pub fn get_tcp_info(fd: RawFd) -> io::Result<TCP_INFO> {
  function get_tcp_info (line 279) | pub fn get_tcp_info(_fd: RawFd) -> io::Result<TCP_INFO> {
  function get_tcp_info (line 284) | pub fn get_tcp_info(_fd: RawSocket) -> io::Result<TCP_INFO> {
  function set_recv_buf (line 290) | pub fn set_recv_buf(fd: RawFd, val: usize) -> Result<()> {
  function set_recv_buf (line 296) | pub fn set_recv_buf(_fd: RawFd, _: usize) -> Result<()> {
  function set_recv_buf (line 301) | pub fn set_recv_buf(_sock: RawSocket, _: usize) -> Result<()> {
  function set_snd_buf (line 307) | pub fn set_snd_buf(fd: RawFd, val: usize) -> Result<()> {
  function set_snd_buf (line 313) | pub fn set_snd_buf(_fd: RawFd, _: usize) -> Result<()> {
  function set_snd_buf (line 318) | pub fn set_snd_buf(_sock: RawSocket, _: usize) -> Result<()> {
  function get_recv_buf (line 323) | pub fn get_recv_buf(fd: RawFd) -> io::Result<usize> {
  function get_recv_buf (line 328) | pub fn get_recv_buf(_fd: RawFd) -> io::Result<usize> {
  function get_recv_buf (line 333) | pub fn get_recv_buf(_sock: RawSocket) -> io::Result<usize> {
  function get_snd_buf (line 338) | pub fn get_snd_buf(fd: RawFd) -> io::Result<usize> {
  function get_snd_buf (line 343) | pub fn get_snd_buf(_fd: RawFd) -> io::Result<usize> {
  function get_snd_buf (line 348) | pub fn get_snd_buf(_sock: RawSocket) -> io::Result<usize> {
  function set_tcp_fastopen_connect (line 354) | pub fn set_tcp_fastopen_connect(fd: RawFd) -> Result<()> {
  function set_tcp_fastopen_connect (line 365) | pub fn set_tcp_fastopen_connect(_fd: RawFd) -> Result<()> {
  function set_tcp_fastopen_connect (line 370) | pub fn set_tcp_fastopen_connect(_sock: RawSocket) -> Result<()> {
  function set_tcp_fastopen_backlog (line 376) | pub fn set_tcp_fastopen_backlog(fd: RawFd, backlog: usize) -> Result<()> {
  function set_tcp_fastopen_backlog (line 382) | pub fn set_tcp_fastopen_backlog(_fd: RawFd, _backlog: usize) -> Result<(...
  function set_tcp_fastopen_backlog (line 387) | pub fn set_tcp_fastopen_backlog(_sock: RawSocket, _backlog: usize) -> Re...
  function set_dscp (line 392) | pub fn set_dscp(fd: RawFd, value: u8) -> Result<()> {
  function set_dscp (line 412) | pub fn set_dscp(_fd: RawFd, _value: u8) -> Result<()> {
  function set_dscp (line 417) | pub fn set_dscp(_sock: RawSocket, _value: u8) -> Result<()> {
  function get_socket_cookie (line 422) | pub fn get_socket_cookie(fd: RawFd) -> io::Result<u64> {
  function get_socket_cookie (line 427) | pub fn get_socket_cookie(_fd: RawFd) -> io::Result<u64> {
  function get_original_dest (line 432) | pub fn get_original_dest(fd: RawFd) -> Result<Option<SocketAddr>> {
  function get_original_dest (line 467) | pub fn get_original_dest(_fd: RawFd) -> Result<Option<SocketAddr>> {
  function get_original_dest (line 472) | pub fn get_original_dest(_sock: RawSocket) -> Result<Option<SocketAddr>> {
  function connect_with (line 485) | pub(crate) async fn connect_with<F: FnOnce(&TcpSocket) -> Result<()> + C...
  function inner_connect_with (line 509) | async fn inner_connect_with<F: FnOnce(&TcpSocket) -> Result<()>>(
  function connect (line 564) | pub async fn connect(addr: &SocketAddr, bind_to: Option<&BindTo>) -> Res...
  function connect_uds (line 570) | pub async fn connect_uds(path: &std::path::Path) -> Result<UnixStream> {
  function wrap_os_connect_error (line 576) | fn wrap_os_connect_error(e: std::io::Error, context: String) -> Box<Erro...
  type TcpKeepalive (line 595) | pub struct TcpKeepalive {
    method fmt (line 613) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method fmt (line 621) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function set_tcp_keepalive (line 627) | pub fn set_tcp_keepalive(stream: &TcpStream, ka: &TcpKeepalive) -> Resul...
  function test_set_recv_buf (line 641) | fn test_set_recv_buf() {
  function test_set_fast_open (line 659) | async fn test_set_fast_open() {

FILE: pingora-core/src/protocols/l4/listener.rs
  type Listener (line 31) | pub enum Listener {
    method from (line 38) | fn from(s: TcpListener) -> Self {
    method from (line 45) | fn from(s: UnixListener) -> Self {
    method accept (line 71) | pub async fn accept(&self) -> io::Result<Stream> {
  method as_raw_fd (line 52) | fn as_raw_fd(&self) -> std::os::unix::io::RawFd {
  method as_raw_socket (line 62) | fn as_raw_socket(&self) -> std::os::windows::io::RawSocket {

FILE: pingora-core/src/protocols/l4/socket.rs
  type SocketAddr (line 32) | pub enum SocketAddr {
    method as_inet (line 40) | pub fn as_inet(&self) -> Option<&StdSockAddr> {
    method as_unix (line 50) | pub fn as_unix(&self) -> Option<&StdUnixSockAddr> {
    method set_port (line 59) | pub fn set_port(&mut self, port: u16) {
    method from_sockaddr_storage (line 66) | fn from_sockaddr_storage(sock: &SockaddrStorage) -> Option<SocketAddr> {
    method from_raw_fd (line 87) | pub fn from_raw_fd(fd: std::os::unix::io::RawFd, peer_addr: bool) -> O...
    method from_raw_socket (line 102) | pub fn from_raw_socket(
    method fmt (line 118) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
    type Err (line 201) | type Err = Box<Error>;
    method from_str (line 205) | fn from_str(s: &str) -> Result<Self, Self::Err> {
    method from_str (line 227) | fn from_str(s: &str) -> Result<Self, Self::Err> {
    type Iter (line 234) | type Iter = std::iter::Once<StdSockAddr>;
    method to_socket_addrs (line 237) | fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
    method from (line 249) | fn from(sockaddr: StdSockAddr) -> Self {
    method from (line 256) | fn from(sockaddr: StdUnixSockAddr) -> Self {
    type Error (line 266) | type Error = String;
    method try_from (line 268) | fn try_from(value: TokioUnixSockAddr) -> Result<Self, Self::Error> {
  method hash (line 134) | fn hash<H: Hasher>(&self, state: &mut H) {
  method eq (line 154) | fn eq(&self, other: &Self) -> bool {
  method partial_cmp (line 168) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method cmp (line 174) | fn cmp(&self, other: &Self) -> Ordering {
  function parse_ip (line 283) | fn parse_ip() {
  function parse_uds (line 290) | fn parse_uds() {
  function parse_uds_with_prefix (line 297) | fn parse_uds_with_prefix() {

FILE: pingora-core/src/protocols/l4/stream.rs
  type RawStream (line 49) | enum RawStream {
  method poll_read (line 57) | fn poll_read(
  method poll_write (line 75) | fn poll_write(self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Pol...
  method poll_flush (line 87) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result...
  method poll_shutdown (line 99) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Res...
  method poll_write_vectored (line 111) | fn poll_write_vectored(
  method is_write_vectored (line 127) | fn is_write_vectored(&self) -> bool {
  method as_raw_fd (line 139) | fn as_raw_fd(&self) -> std::os::unix::io::RawFd {
  method as_raw_socket (line 150) | fn as_raw_socket(&self) -> std::os::windows::io::RawSocket {
  type RawStreamWrapper (line 160) | struct RawStreamWrapper {
    method new (line 175) | pub fn new(stream: RawStream) -> Self {
    method enable_rx_ts (line 187) | pub fn enable_rx_ts(&mut self, enable_rx_ts: bool) {
  method poll_read (line 194) | fn poll_read(
  method poll_read (line 212) | fn poll_read(
  method poll_write (line 286) | fn poll_write(self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Pol...
  method poll_flush (line 298) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result...
  method poll_shutdown (line 310) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Res...
  method poll_write_vectored (line 322) | fn poll_write_vectored(
  method is_write_vectored (line 338) | fn is_write_vectored(&self) -> bool {
  method as_raw_fd (line 345) | fn as_raw_fd(&self) -> std::os::unix::io::RawFd {
  method as_raw_socket (line 352) | fn as_raw_socket(&self) -> std::os::windows::io::RawSocket {
  constant BUF_READ_SIZE (line 359) | const BUF_READ_SIZE: usize = 64 * 1024;
  constant BUF_WRITE_SIZE (line 364) | const BUF_WRITE_SIZE: usize = 1460;
  type Stream (line 371) | pub struct Stream {
    method stream (line 390) | fn stream(&self) -> &BufStream<RawStreamWrapper> {
    method stream_mut (line 394) | fn stream_mut(&mut self) -> &mut BufStream<RawStreamWrapper> {
    method set_nodelay (line 399) | pub fn set_nodelay(&mut self) -> Result<()> {
    method set_keepalive (line 415) | pub fn set_keepalive(&mut self, ka: &TcpKeepalive) -> Result<()> {
    method set_rx_timestamp (line 431) | pub fn set_rx_timestamp(&mut self) -> Result<()> {
    method set_rx_timestamp (line 446) | pub fn set_rx_timestamp(&mut self) -> io::Result<()> {
    method rewind (line 451) | pub(crate) fn rewind(&mut self, data: &[u8]) {
    method set_buffer (line 459) | pub(crate) fn set_buffer(&mut self) {
    method from (line 471) | fn from(s: TcpStream) -> Self {
    method from (line 492) | fn from(s: virt::VirtualSocketStream) -> Self {
    method from (line 514) | fn from(s: UnixStream) -> Self {
  method as_raw_fd (line 536) | fn as_raw_fd(&self) -> std::os::unix::io::RawFd {
  method as_raw_socket (line 543) | fn as_raw_socket(&self) -> std::os::windows::io::RawSocket {
  method id (line 550) | fn id(&self) -> UniqueIDType {
  method id (line 557) | fn id(&self) -> usize {
  method try_peek (line 566) | async fn try_peek(&mut self, buf: &mut [u8]) -> std::io::Result<bool> {
  method shutdown (line 577) | async fn shutdown(&mut self) {
  method get_timing_digest (line 585) | fn get_timing_digest(&self) -> Vec<Option<TimingDigest>> {
  method get_read_pending_time (line 593) | fn get_read_pending_time(&self) -> Duration {
  method get_write_pending_time (line 597) | fn get_write_pending_time(&self) -> Duration {
  method get_proxy_digest (line 603) | fn get_proxy_digest(&self) -> Option<Arc<ProxyDigest>> {
  method set_proxy_digest (line 607) | fn set_proxy_digest(&mut self, digest: ProxyDigest) {
  method get_socket_digest (line 613) | fn get_socket_digest(&self) -> Option<Arc<SocketDigest>> {
  method set_socket_digest (line 617) | fn set_socket_digest(&mut self, socket_digest: SocketDigest) {
  method drop (line 623) | fn drop(&mut self) {
  method poll_read (line 662) | fn poll_read(
  method poll_write (line 687) | fn poll_write(
  method poll_flush (line 701) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Re...
  method poll_shutdown (line 707) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<io:...
  method poll_write_vectored (line 711) | fn poll_write_vectored(
  method is_write_vectored (line 728) | fn is_write_vectored(&self) -> bool {
  type WriteVec (line 754) | pub struct WriteVec<'a, W, B> {
  type WriteVecAll (line 760) | pub struct WriteVecAll<'a, W, B> {
  type AsyncWriteVec (line 765) | pub trait AsyncWriteVec {
    method poll_write_vec (line 766) | fn poll_write_vec<B: Buf>(
    method write_vec (line 772) | fn write_vec<'a, B>(&'a mut self, src: &'a mut B) -> WriteVec<'a, Self...
    method write_vec_all (line 783) | fn write_vec_all<'a, B>(&'a mut self, src: &'a mut B) -> WriteVecAll<'...
    method poll_write_vec (line 832) | fn poll_write_vec<B: Buf>(
  type Output (line 800) | type Output = io::Result<usize>;
  method poll (line 802) | fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<io::Res...
  type Output (line 813) | type Output = io::Result<()>;
  method poll (line 815) | fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<io::Res...
  type AccumulatedDuration (line 861) | struct AccumulatedDuration {
    method new (line 867) | fn new() -> Self {
    method start (line 874) | fn start(&mut self) {
    method stop (line 880) | fn stop(&mut self) {
    method poll_write_time (line 886) | fn poll_write_time(&mut self, result: &Poll<io::Result<usize>>, buf_si...
    method poll_time (line 903) | fn poll_time(&mut self, result: &Poll<io::Result<()>>) {
  function test_rx_timestamp (line 925) | async fn test_rx_timestamp() {
  function test_rx_timestamp_standard_path (line 954) | async fn test_rx_timestamp_standard_path() {
  function test_stream_rewind (line 978) | async fn test_stream_rewind() {
  function test_stream_peek (line 1015) | async fn test_stream_peek() {
  function test_stream_two_subsequent_peek_calls_before_read (line 1042) | async fn test_stream_two_subsequent_peek_calls_before_read() {

FILE: pingora-core/src/protocols/l4/virt.rs
  type VirtualSockOpt (line 15) | pub enum VirtualSockOpt {
  type VirtualSocket (line 21) | pub trait VirtualSocket: AsyncRead + AsyncWrite + Unpin + Send + Sync + ...
    method set_socket_option (line 23) | fn set_socket_option(&self, opt: VirtualSockOpt) -> std::io::Result<()>;
    method set_socket_option (line 135) | fn set_socket_option(&self, _opt: VirtualSockOpt) -> std::io::Result<(...
  type VirtualSocketStream (line 28) | pub struct VirtualSocketStream {
    method new (line 33) | pub fn new(socket: Box<dyn VirtualSocket>) -> Self {
    method set_socket_option (line 38) | pub fn set_socket_option(&self, opt: VirtualSockOpt) -> std::io::Resul...
  method poll_read (line 45) | fn poll_read(
  method poll_write (line 56) | fn poll_write(
  method poll_flush (line 65) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::i...
  method poll_shutdown (line 70) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std...
  type StaticVirtualSocket (line 86) | struct StaticVirtualSocket {
  method poll_read (line 93) | fn poll_read(
  method poll_write (line 114) | fn poll_write(
  method poll_flush (line 125) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::...
  method poll_shutdown (line 129) | fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<st...
  function test_stream_virtual (line 144) | async fn test_stream_virtual() {

FILE: pingora-core/src/protocols/mod.rs
  type UniqueIDType (line 38) | pub type UniqueIDType = i32;
  type UniqueIDType (line 40) | pub type UniqueIDType = usize;
  type Shutdown (line 44) | pub trait Shutdown {
    method shutdown (line 45) | async fn shutdown(&mut self) -> ();
    method shutdown (line 145) | async fn shutdown(&mut self) -> () {}
    method shutdown (line 175) | async fn shutdown(&mut self) -> () {}
    method shutdown (line 204) | async fn shutdown(&mut self) -> () {}
    method shutdown (line 244) | async fn shutdown(&mut self) -> () {}
  type UniqueID (line 49) | pub trait UniqueID {
    method id (line 52) | fn id(&self) -> UniqueIDType;
    method id (line 148) | fn id(&self) -> UniqueIDType {
    method id (line 178) | fn id(&self) -> UniqueIDType {
    method id (line 207) | fn id(&self) -> UniqueIDType {
    method id (line 247) | fn id(&self) -> UniqueIDType {
  type Ssl (line 56) | pub trait Ssl {
    method get_ssl (line 58) | fn get_ssl(&self) -> Option<&TlsRef> {
    method get_ssl_digest (line 63) | fn get_ssl_digest(&self) -> Option<Arc<tls::SslDigest>> {
    method selected_alpn_proto (line 68) | fn selected_alpn_proto(&self) -> Option<ALPN> {
  type Peek (line 75) | pub trait Peek {
    method try_peek (line 79) | async fn try_peek(&mut self, _buf: &mut [u8]) -> std::io::Result<bool> {
  type IO (line 88) | pub trait IO:
    method as_any (line 104) | fn as_any(&self) -> &dyn Any;
    method into_any (line 106) | fn into_any(self: Box<Self>) -> Box<dyn Any>;
    method as_any (line 127) | fn as_any(&self) -> &dyn Any {
    method into_any (line 130) | fn into_any(self: Box<Self>) -> Box<dyn Any> {
  type Stream (line 136) | pub type Stream = Box<dyn IO>;
  method get_timing_digest (line 154) | fn get_timing_digest(&self) -> Vec<Option<TimingDigest>> {
  method get_proxy_digest (line 159) | fn get_proxy_digest(&self) -> Option<Arc<raw_connect::ProxyDigest>> {
  method get_socket_digest (line 164) | fn get_socket_digest(&self) -> Option<Arc<SocketDigest>> {
  method get_timing_digest (line 184) | fn get_timing_digest(&self) -> Vec<Option<TimingDigest>> {
  method get_proxy_digest (line 189) | fn get_proxy_digest(&self) -> Option<Arc<raw_connect::ProxyDigest>> {
  method get_socket_digest (line 194) | fn get_socket_digest(&self) -> Option<Arc<SocketDigest>> {
  method get_timing_digest (line 213) | fn get_timing_digest(&self) -> Vec<Option<TimingDigest>> {
  method get_proxy_digest (line 218) | fn get_proxy_digest(&self) -> Option<Arc<raw_connect::ProxyDigest>> {
  method get_socket_digest (line 223) | fn get_socket_digest(&self) -> Option<Arc<SocketDigest>> {
  method get_timing_digest (line 253) | fn get_timing_digest(&self) -> Vec<Option<TimingDigest>> {
  method get_proxy_digest (line 258) | fn get_proxy_digest(&self) -> Option<Arc<raw_connect::ProxyDigest>> {
  method get_socket_digest (line 263) | fn get_socket_digest(&self) -> Option<Arc<SocketDigest>> {
  type ConnFdReusable (line 272) | pub(crate) trait ConnFdReusable {
    method check_fd_match (line 273) | fn check_fd_match<V: AsRawFd>(&self, fd: V) -> bool;
    method check_fd_match (line 295) | fn check_fd_match<V: AsRawFd>(&self, fd: V) -> bool {
    method check_fd_match (line 317) | fn check_fd_match<V: AsRawFd>(&self, fd: V) -> bool {
    method check_fd_match (line 345) | fn check_fd_match<V: AsRawFd>(&self, fd: V) -> bool {
  type ConnSockReusable (line 277) | pub(crate) trait ConnSockReusable {
    method check_sock_match (line 278) | fn check_sock_match<V: AsRawSocket>(&self, sock: V) -> bool;
    method check_sock_match (line 308) | fn check_sock_match<V: AsRawSocket>(&self, sock: V) -> bool {
    method check_sock_match (line 376) | fn check_sock_match<V: AsRawSocket>(&self, sock: V) -> bool {

FILE: pingora-core/src/protocols/raw_connect.rs
  function connect (line 40) | pub async fn connect<P>(
  function generate_connect_header (line 70) | pub fn generate_connect_header<'a, H, S>(
  type ProxyDigest (line 113) | pub struct ProxyDigest {
    method new (line 121) | pub fn new(
  type ConnectProxyError (line 134) | pub struct ConnectProxyError {
    method boxed_new (line 140) | pub fn boxed_new(response: Box<ResponseHeader>) -> Box<Self> {
    method fmt (line 146) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function http_req_header_to_wire_auth_form (line 166) | fn http_req_header_to_wire_auth_form(req: &ReqHeader) -> BytesMut {
  function validate_connect_response (line 202) | fn validate_connect_response<P>(
  function test_generate_connect_header (line 242) | fn test_generate_connect_header() {
  function test_generate_connect_header_ipv6 (line 254) | fn test_generate_connect_header_ipv6() {
  function test_request_to_wire_auth_form (line 266) | fn test_request_to_wire_auth_form() {
  function test_validate_connect_response (line 282) | fn test_validate_connect_response() {
  function test_connect_write_request (line 339) | async fn test_connect_write_request() {

FILE: pingora-core/src/protocols/tls/boringssl_openssl/client.rs
  function handshake (line 30) | pub async fn handshake<S: IO>(
  method get_timing_digest (line 92) | fn get_timing_digest(&self) -> Vec<Option<TimingDigest>> {
  method get_read_pending_time (line 97) | fn get_read_pending_time(&self) -> Duration {
  method get_write_pending_time (line 101) | fn get_write_pending_time(&self) -> Duration {
  method get_proxy_digest (line 110) | fn get_proxy_digest(&self) -> Option<Arc<ProxyDigest>> {
  method get_socket_digest (line 119) | fn get_socket_digest(&self) -> Option<Arc<SocketDigest>> {
  method set_socket_digest (line 122) | fn set_socket_digest(&mut self, socket_digest: SocketDigest) {

FILE: pingora-core/src/protocols/tls/boringssl_openssl/mod.rs
  type TlsRef (line 28) | pub type TlsRef = SslRef;
  type CaType (line 29) | pub type CaType = Box<[X509]>;

FILE: pingora-core/src/protocols/tls/boringssl_openssl/server.rs
  function prepare_tls_stream (line 32) | pub fn prepare_tls_stream<S: IO>(ssl_acceptor: &SslAcceptor, io: S) -> R...
  function handshake (line 39) | pub async fn handshake<S: IO>(ssl_acceptor: &SslAcceptor, io: S) -> Resu...
  function handshake_with_callback (line 49) | pub async fn handshake_with_callback<S: IO>(
  method shutdown (line 84) | async fn shutdown(&mut self) {
  type ResumableAccept (line 96) | pub trait ResumableAccept {
    method start_accept (line 103) | async fn start_accept(self: Pin<&mut Self>) -> Result<bool, ssl::Error>;
    method resume_accept (line 108) | async fn resume_accept(self: Pin<&mut Self>) -> Result<(), ssl::Error>;
    method start_accept (line 113) | async fn start_accept(mut self: Pin<&mut Self>) -> Result<bool, ssl::E...
    method resume_accept (line 131) | async fn resume_accept(mut self: Pin<&mut Self>) -> Result<(), ssl::Er...
  function client_task (line 154) | async fn client_task(client: DuplexStream) {
  function test_async_cert (line 170) | async fn test_async_cert() {
  function test_handshake_complete_callback (line 209) | async fn test_handshake_complete_callback() {

FILE: pingora-core/src/protocols/tls/boringssl_openssl/stream.rs
  type SslStream (line 38) | pub struct SslStream<T> {
  function new (line 52) | pub fn new(ssl: ssl::Ssl, stream: T) -> Result<Self> {
  function connect (line 64) | pub async fn connect(&mut self) -> Result<(), ssl::Error> {
  function accept (line 73) | pub async fn accept(&mut self) -> Result<(), ssl::Error> {
  function clear_error (line 82) | fn clear_error() {
  function ssl_digest (line 91) | pub fn ssl_digest(&self) -> Option<Arc<SslDigest>> {
  function ssl_digest_mut (line 97) | pub(crate) fn ssl_digest_mut(&mut self) -> Option<&mut SslDigest> {
  type Target (line 105) | type Target = InnerSsl<T>;
  method deref (line 107) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 113) | fn deref_mut(&mut self) -> &mut Self::Target {
  method poll_read (line 122) | fn poll_read(
  method poll_write (line 136) | fn poll_write(
  method poll_flush (line 145) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Re...
  method poll_shutdown (line 150) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<io:...
  method poll_write_vectored (line 155) | fn poll_write_vectored(
  method is_write_vectored (line 164) | fn is_write_vectored(&self) -> bool {
  method id (line 173) | fn id(&self) -> UniqueIDType {
  method get_ssl (line 179) | fn get_ssl(&self) -> Option<&ssl::SslRef> {
  method get_ssl_digest (line 183) | fn get_ssl_digest(&self) -> Option<Arc<SslDigest>> {
  method selected_alpn_proto (line 188) | fn selected_alpn_proto(&self) -> Option<ALPN> {
  method from_ssl (line 195) | pub fn from_ssl(ssl: &SslRef) -> Self {

FILE: pingora-core/src/protocols/tls/digest.rs
  type SslDigest (line 23) | pub struct SslDigest {
    method new (line 40) | pub fn new<S>(
  type SslDigestExtension (line 63) | pub struct SslDigestExtension {
    method get (line 71) | pub fn get<T>(&self) -> Option<&T>
    method set (line 79) | pub(crate) fn set(&mut self, value: Arc<dyn Any + Send + Sync>) {

FILE: pingora-core/src/protocols/tls/mod.rs
  type HandshakeCompleteHook (line 46) | pub type HandshakeCompleteHook = std::sync::Arc<
  type ALPN (line 52) | pub enum ALPN {
    method fmt (line 110) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method new (line 128) | pub fn new(max: u8, min: u8) -> Self {
    method get_max_http_version (line 139) | pub fn get_max_http_version(&self) -> u8 {
    method get_min_http_version (line 148) | pub fn get_min_http_version(&self) -> u8 {
    method to_wire_preference (line 157) | pub(crate) fn to_wire_preference(&self) -> &[u8] {
    method from_wire_selected (line 169) | pub(crate) fn from_wire_selected(raw: &[u8]) -> Option<Self> {
    method to_wire_protocols (line 178) | pub(crate) fn to_wire_protocols(&self) -> Vec<Vec<u8>> {
    method to_wire_protocols (line 188) | pub(crate) fn to_wire_protocols(&self) -> Vec<Vec<u8>> {
  type CustomALPN (line 66) | pub struct CustomALPN {
    method new (line 73) | pub fn new(proto: Vec<u8>) -> Self {
    method protocol (line 99) | pub fn protocol(&self) -> &[u8] {
    method as_wire (line 104) | pub fn as_wire(&self) -> &[u8] {
  function test_valid_alpn_construction_and_versions (line 203) | fn test_valid_alpn_construction_and_versions() {
  function test_empty_custom_alpn (line 221) | fn test_empty_custom_alpn() {
  function test_large_custom_alpn (line 226) | fn test_large_custom_alpn() {
  function test_custom_h1_alpn (line 232) | fn test_custom_h1_alpn() {
  function test_custom_h2_alpn (line 237) | fn test_custom_h2_alpn() {

FILE: pingora-core/src/protocols/tls/noop_tls/mod.rs
  type TlsRef (line 18) | pub struct TlsRef;
  type CaType (line 20) | pub type CaType = [CertWrapper];
  type CertWrapper (line 23) | pub struct CertWrapper;
    method not_after (line 26) | pub fn not_after(&self) -> &str {
  type Connector (line 43) | pub struct Connector {
    method new (line 53) | pub fn new(_: Option<ConnectorOptions>) -> Self {
  type TlsConnector (line 48) | pub struct TlsConnector;
  type TlsSettings (line 50) | pub struct TlsSettings;
    method build (line 83) | pub fn build(&self) -> Acceptor {
    method intermediate (line 87) | pub fn intermediate(_: &str, _: &str) -> Result<Self> {
    method enable_h2 (line 91) | pub fn enable_h2(&mut self) {}
  function connect (line 58) | pub async fn connect<T, P>(
  type Acceptor (line 78) | pub struct Acceptor;
    method tls_handshake (line 95) | pub async fn tls_handshake<S: AsyncRead + AsyncWrite>(&self, _: S) -> ...
  type TlsSettings (line 80) | pub struct TlsSettings;
    method build (line 83) | pub fn build(&self) -> Acceptor {
    method intermediate (line 87) | pub fn intermediate(_: &str, _: &str) -> Result<Self> {
    method enable_h2 (line 91) | pub fn enable_h2(&mut self) {}
  type SslStream (line 116) | pub struct SslStream<S> {
  method default (line 121) | fn default() -> Self {
  method poll_read (line 132) | fn poll_read(
  method poll_write (line 145) | fn poll_write(
  method poll_flush (line 153) | fn poll_flush(self: Pin<&mut Self>, _ctx: &mut Context<'_>) -> Poll<std:...
  method poll_shutdown (line 157) | fn poll_shutdown(
  method shutdown (line 167) | async fn shutdown(&mut self) {}
  method id (line 171) | fn id(&self) -> crate::protocols::UniqueIDType {
  method get_timing_digest (line 179) | fn get_timing_digest(&self) -> Vec<Option<crate::protocols::TimingDigest...
  method get_proxy_digest (line 185) | fn get_proxy_digest(
  method get_socket_digest (line 193) | fn get_socket_digest(&self) -> Option<std::sync::Arc<crate::protocols::S...
  type CertKey (line 207) | pub struct CertKey;
  method fmt (line 210) | fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function get_organization_unit (line 215) | pub fn get_organization_unit(_: &CertWrapper) -> Option<String> {

FILE: pingora-core/src/protocols/tls/rustls/client.rs
  function handshake (line 24) | pub async fn handshake<S: IO>(

FILE: pingora-core/src/protocols/tls/rustls/mod.rs
  type CaType (line 23) | pub type CaType = [WrappedX509];
  type TlsRef (line 25) | pub struct TlsRef;

FILE: pingora-core/src/protocols/tls/rustls/server.rs
  function start_accept (line 29) | async fn start_accept(mut self: Pin<&mut Self>) -> Result<bool> {
  function resume_accept (line 45) | async fn resume_accept(mut self: Pin<&mut Self>) -> Result<()> {
  function prepare_tls_stream (line 51) | async fn prepare_tls_stream<S: IO>(acceptor: &Acceptor, io: S) -> Result...
  function handshake (line 58) | pub async fn handshake<S: IO>(acceptor: &Acceptor, io: S) -> Result<TlsS...
  function handshake_with_callback (line 69) | pub async fn handshake_with_callback<S: IO>(
  method shutdown (line 101) | async fn shutdown(&mut self) {
  function test_async_cert (line 113) | async fn test_async_cert() {

FILE: pingora-core/src/protocols/tls/rustls/stream.rs
  type InnerStream (line 38) | pub struct InnerStream<T> {
  type TlsStream (line 46) | pub struct TlsStream<T> {
  function from_connector (line 60) | pub async fn from_connector(connector: &TlsConnector, domain: &str, stre...
  function from_acceptor (line 80) | pub(crate) async fn from_acceptor(acceptor: &Acceptor, stream: T) -> Res...
  method get_socket_digest (line 97) | fn get_socket_digest(&self) -> Option<Arc<SocketDigest>> {
  method set_socket_digest (line 100) | fn set_socket_digest(&mut self, socket_digest: SocketDigest) {
  method get_timing_digest (line 109) | fn get_timing_digest(&self) -> Vec<Option<TimingDigest>> {
  method get_read_pending_time (line 114) | fn get_read_pending_time(&self) -> Duration {
  method get_write_pending_time (line 118) | fn get_write_pending_time(&self) -> Duration {
  method get_proxy_digest (line 127) | fn get_proxy_digest(&self) -> Option<Arc<ProxyDigest>> {
  function ssl_digest (line 133) | pub fn ssl_digest(&self) -> Option<Arc<SslDigest>> {
  function ssl_digest_mut (line 139) | pub(crate) fn ssl_digest_mut(&mut self) -> Option<&mut SslDigest> {
  type Target (line 145) | type Target = InnerStream<T>;
  method deref (line 147) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 153) | fn deref_mut(&mut self) -> &mut Self::Target {
  function connect (line 163) | pub(crate) async fn connect(&mut self) -> Result<()> {
  function accept (line 171) | pub(crate) async fn accept(&mut self) -> Result<()> {
  method poll_read (line 183) | fn poll_read(
  method poll_write (line 196) | fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) ->...
  method poll_flush (line 200) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<IoResu...
  method poll_shutdown (line 204) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<IoR...
  method poll_write_vectored (line 208) | fn poll_write_vectored(
  method is_write_vectored (line 216) | fn is_write_vectored(&self) -> bool {
  method id (line 225) | fn id(&self) -> UniqueIDType {
  method get_ssl_digest (line 231) | fn get_ssl_digest(&self) -> Option<Arc<SslDigest>> {
  method selected_alpn_proto (line 235) | fn selected_alpn_proto(&self) -> Option<ALPN> {
  function from_connector (line 254) | pub(crate) async fn from_connector(
  function from_acceptor (line 267) | pub(crate) async fn from_acceptor(acceptor: &Acceptor, stream: T) -> Res...
  function connect (line 280) | pub(crate) async fn connect(&mut self) -> Result<()> {
  function accept (line 296) | pub(crate) async fn accept(&mut self) -> Result<()> {
  function digest (line 310) | pub(crate) fn digest(&mut self) -> Option<Arc<SslDigest>> {
  method get_socket_digest (line 319) | fn get_socket_digest(&self) -> Option<Arc<SocketDigest>> {
  method set_socket_digest (line 326) | fn set_socket_digest(&mut self, socket_digest: SocketDigest) {
  method get_timing_digest (line 340) | fn get_timing_digest(&self) -> Vec<Option<TimingDigest>> {
  method get_proxy_digest (line 354) | fn get_proxy_digest(&self) -> Option<Arc<ProxyDigest>> {
  method from_stream (line 364) | fn from_stream<T>(stream: &Option<RusTlsStream<T>>) -> Self {

FILE: pingora-core/src/protocols/tls/s2n/client.rs
  function handshake (line 24) | pub async fn handshake<S: IO>(

FILE: pingora-core/src/protocols/tls/s2n/mod.rs
  type CaType (line 31) | pub type CaType = X509Pem;
  type PskType (line 33) | pub type PskType = PskConfig;
  type PskConfig (line 36) | pub struct PskConfig {
    method new (line 41) | pub fn new(keys: Vec<Psk>) -> Self {
  method hash (line 47) | fn hash<H: Hasher>(&self, state: &mut H) {
  type Psk (line 56) | pub struct Psk {
    method new (line 63) | pub fn new(identity: String, secret: Vec<u8>, hmac: PskHmac) -> Self {
  type TlsRef (line 72) | pub struct TlsRef;
  type S2NConnectionBuilder (line 81) | pub struct S2NConnectionBuilder {
  type Output (line 88) | type Output = Connection;
  method build_connection (line 89) | fn build_connection(&self, mode: Mode) -> std::result::Result<Self::Outp...

FILE: pingora-core/src/protocols/tls/s2n/server.rs
  function handshake (line 23) | pub async fn handshake<S: IO>(acceptor: &Acceptor, stream: S) -> Result<...

FILE: pingora-core/src/protocols/tls/s2n/stream.rs
  type AutoFlushableStream (line 46) | pub struct AutoFlushableStream<T: AsyncRead + AsyncWrite + Unpin> {
  function new (line 55) | pub fn new(stream: T, auto_flush: bool) -> Self {
  function set_auto_flush (line 59) | pub fn set_auto_flush(&mut self, auto_flush: bool) {
  method poll_read (line 68) | fn poll_read(
  method poll_write (line 81) | fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) ->...
  method poll_flush (line 89) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<IoResu...
  method poll_shutdown (line 93) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<IoR...
  method poll_write_vectored (line 97) | fn poll_write_vectored(
  method is_write_vectored (line 109) | fn is_write_vectored(&self) -> bool {
  type TlsStream (line 115) | pub struct TlsStream<T: AsyncRead + AsyncWrite + Unpin> {
  function from_s2n_stream (line 125) | pub fn from_s2n_stream(stream: S2NTlsStream<AutoFlushableStream<T>>) -> ...
  type Target (line 138) | type Target = T;
  method deref (line 140) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 146) | fn deref_mut(&mut self) -> &mut Self::Target {
  type Target (line 152) | type Target = S2NTlsStream<AutoFlushableStream<T>>;
  method deref (line 154) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 160) | fn deref_mut(&mut self) -> &mut Self::Target {
  method get_ssl_digest (line 166) | fn get_ssl_digest(&self) -> Option<Arc<SslDigest>> {
  method selected_alpn_proto (line 170) | fn selected_alpn_proto(&self) -> Option<ALPN> {
  function ssl_digest (line 185) | pub fn ssl_digest(&self) -> Option<Arc<SslDigest>> {
  method poll_read (line 194) | fn poll_read(
  method poll_write (line 208) | fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) ->...
  method poll_flush (line 212) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<IoResu...
  method poll_shutdown (line 216) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<IoR...
  method poll_write_vectored (line 220) | fn poll_write_vectored(
  method is_write_vectored (line 228) | fn is_write_vectored(&self) -> bool {
  method id (line 237) | fn id(&self) -> UniqueIDType {
  method get_socket_digest (line 246) | fn get_socket_digest(&self) -> Option<Arc<SocketDigest>> {
  method set_socket_digest (line 249) | fn set_socket_digest(&mut self, socket_digest: SocketDigest) {
  method get_timing_digest (line 258) | fn get_timing_digest(&self) -> Vec<Option<TimingDigest>> {
  method get_read_pending_time (line 264) | fn get_read_pending_time(&self) -> Duration {
  method get_write_pending_time (line 268) | fn get_write_pending_time(&self) -> Duration {
  method get_proxy_digest (line 277) | fn get_proxy_digest(&self) -> Option<Arc<ProxyDigest>> {
  method from_stream (line 283) | fn from_stream<T: AsyncRead + AsyncWrite + Unpin>(stream: Option<&S2NTls...
  method shutdown (line 323) | async fn shutdown(&mut self) -> () {

FILE: pingora-core/src/protocols/windows.rs
  function peer_addr (line 29) | pub(crate) fn peer_addr(raw_sock: RawSocket) -> io::Result<SocketAddr> {
  function local_addr (line 46) | pub(crate) fn local_addr(raw_sock: RawSocket) -> io::Result<SocketAddr> {
  function sockaddr_to_addr (line 64) | fn sockaddr_to_addr(storage: &SOCKADDR_STORAGE, len: usize) -> io::Resul...
  function assert_listener_and_stream (line 98) | async fn assert_listener_and_stream(addr: &str) {
  function get_v4_addrs_from_raw_socket (line 122) | async fn get_v4_addrs_from_raw_socket() {
  function get_v6_addrs_from_raw_socket (line 126) | async fn get_v6_addrs_from_raw_socket() {

FILE: pingora-core/src/server/bootstrap_services.rs
  type BootstrapService (line 37) | pub struct BootstrapService {
    method new (line 49) | pub fn new(inner: &Arc<Mutex<Bootstrap>>) -> Self {
  type SentryInitService (line 44) | pub struct SentryInitService {
    method new (line 57) | pub fn new(inner: &Arc<Mutex<Bootstrap>>) -> Self {
  type Bootstrap (line 65) | pub struct Bootstrap {
    method new (line 88) | pub fn new(
    method set_sentry_config (line 114) | pub fn set_sentry_config(&mut self, sentry_config: Option<ClientOption...
    method start_sentry (line 121) | fn start_sentry(&mut self) {
    method bootstrap (line 127) | pub fn bootstrap(&mut self) {
    method load_fds (line 170) | fn load_fds(&mut self, upgrade: bool) -> Result<(), nix::Error> {
    method get_fds (line 181) | pub fn get_fds(&self) -> Option<ListenFds> {
  method start_with_ready_notifier (line 188) | async fn start_with_ready_notifier(
  method start_with_ready_notifier (line 200) | async fn start_with_ready_notifier(

FILE: pingora-core/src/server/configuration/mod.rs
  constant DEFAULT_MAX_RETRIES (line 30) | const DEFAULT_MAX_RETRIES: usize = 16;
  type ServerConf (line 42) | pub struct ServerConf {
    method load_from_yaml (line 200) | pub fn load_from_yaml<P>(path: P) -> Result<Self>
    method load_yaml_with_opt_override (line 211) | pub fn load_yaml_with_opt_override(opt: &Opt) -> Result<Self> {
    method new (line 221) | pub fn new() -> Option<Self> {
    method new_with_opt_override (line 225) | pub fn new_with_opt_override(opt: &Opt) -> Option<Self> {
    method from_yaml (line 236) | pub fn from_yaml(conf_str: &str) -> Result<Self> {
    method to_yaml (line 246) | pub fn to_yaml(&self) -> String {
    method validate (line 250) | pub fn validate(self) -> Result<Self> {
    method merge_with_opt (line 255) | pub fn merge_with_opt(&mut self, opt: &Opt) {
  method default (line 122) | fn default() -> Self {
  type Opt (line 156) | pub struct Opt {
    method parse_args (line 266) | pub fn parse_args() -> Self {
    method parse_from_args (line 270) | pub fn parse_from_args<I, T>(args: I) -> Self
  function init_log (line 283) | fn init_log() {
  function not_a_test_i_cannot_write_yaml_by_hand (line 288) | fn not_a_test_i_cannot_write_yaml_by_hand() {
  function test_load_file (line 320) | fn test_load_file() {
  function test_default (line 338) | fn test_default() {

FILE: pingora-core/src/server/daemon.rs
  function move_old_pid (line 29) | fn move_old_pid(path: &str) {
  function gid_for_username (line 48) | unsafe fn gid_for_username(name: &CString) -> Option<libc::gid_t> {
  function daemonize (line 58) | pub fn daemonize(conf: &ServerConf) {

FILE: pingora-core/src/server/mod.rs
  constant EXIT_TIMEOUT (line 56) | const EXIT_TIMEOUT: u64 = 60 * 5;
  constant CLOSE_TIMEOUT (line 59) | const CLOSE_TIMEOUT: u64 = 5;
  type ShutdownType (line 61) | enum ShutdownType {
  type ServiceWrapper (line 67) | pub(crate) struct ServiceWrapper {
  type ExecutionPhase (line 76) | pub enum ExecutionPhase {
  type ShutdownWatch (line 118) | pub type ShutdownWatch = watch::Receiver<bool>;
  type ListenFds (line 120) | pub type ListenFds = Arc<TokioMutex<Fds>>;
  type ShutdownSignal (line 124) | pub enum ShutdownSignal {
  type ShutdownSignalWatch (line 138) | pub trait ShutdownSignalWatch {
    method recv (line 140) | async fn recv(&self) -> ShutdownSignal;
    method recv (line 154) | async fn recv(&self) -> ShutdownSignal {
  type UnixShutdownSignalWatch (line 149) | pub struct UnixShutdownSignalWatch;
  type RunArgs (line 174) | pub struct RunArgs {
  method default (line 182) | fn default() -> Self {
  method default (line 189) | fn default() -> Self {
  type Server (line 199) | pub struct Server {
    method watch_execution_phase (line 232) | pub fn watch_execution_phase(&self) -> broadcast::Receiver<ExecutionPh...
    method main_loop (line 237) | async fn main_loop(&self, run_args: RunArgs) -> ShutdownType {
    method main_loop (line 321) | async fn main_loop(&self, _run_args: RunArgs) -> ShutdownType {
    method set_sentry_config (line 361) | pub fn set_sentry_config(&mut self, sentry_config: ClientOptions) {
    method listen_fds (line 367) | fn listen_fds(&self) -> Option<ListenFds> {
    method run_service (line 372) | fn run_service(
    method new_with_opt_and_conf (line 429) | pub fn new_with_opt_and_conf(raw_opt: impl Into<Option<Opt>>, mut conf...
    method new (line 467) | pub fn new(opt: impl Into<Option<Opt>>) -> Result<Server> {
    method add_init_service (line 510) | fn add_init_service(&mut self, service: impl ServiceWithDependents + '...
    method apply_init_service_dependencies (line 516) | fn apply_init_service_dependencies(&mut self) {
    method add_service (line 547) | pub fn add_service(&mut self, service: impl ServiceWithDependents + 's...
    method add_boxed_service (line 564) | pub fn add_boxed_service(
    method add_services (line 591) | pub fn add_services(
    method bootstrap (line 605) | pub fn bootstrap(&mut self) {
    method bootstrap_as_a_service (line 616) | pub fn bootstrap_as_a_service(&mut self) -> ServiceHandle {
    method run_forever (line 637) | pub fn run_forever(self) -> ! {
    method run (line 653) | pub fn run(mut self, run_args: RunArgs) {
    method create_runtime (line 821) | fn create_runtime(name: &str, threads: usize, work_steal: bool) -> Run...

FILE: pingora-core/src/server/transfer_fd/mod.rs
  type Fds (line 34) | pub struct Fds {
    method new (line 39) | pub fn new() -> Self {
    method add (line 45) | pub fn add(&mut self, bind: String, fd: RawFd) {
    method get (line 49) | pub fn get(&self, bind: &str) -> Option<&RawFd> {
    method serialize (line 53) | pub fn serialize(&self) -> (Vec<String>, Vec<RawFd>) {
    method deserialize (line 57) | pub fn deserialize(&mut self, binds: Vec<String>, fds: Vec<RawFd>) {
    method send_to_sock (line 64) | pub fn send_to_sock<P>(&self, path: &P) -> Result<usize, Error>
    method get_from_sock (line 74) | pub fn get_from_sock<P>(&mut self, path: &P) -> Result<(), Error>
  function serialize_vec_string (line 86) | fn serialize_vec_string(vec_string: &[String], mut buf: &mut [u8]) -> us...
  function deserialize_vec_string (line 94) | fn deserialize_vec_string(buf: &[u8]) -> Result<Vec<String>, Error> {
  function get_fds_from (line 100) | pub fn get_fds_from<P>(
  function get_fds_from (line 183) | pub fn get_fds_from<P>(
  constant MAX_RETRY (line 196) | const MAX_RETRY: usize = 5;
  constant RETRY_INTERVAL (line 198) | const RETRY_INTERVAL: time::Duration = time::Duration::from_secs(1);
  function accept_with_retry_timeout (line 201) | fn accept_with_retry_timeout(listen_fd: i32, max_retry: usize) -> Result...
  function send_fds_to (line 229) | pub fn send_fds_to<P>(
  function send_fds_to (line 335) | pub fn send_fds_to<P>(
  function init_log (line 353) | fn init_log() {
  function test_add_get (line 358) | fn test_add_get() {
  function test_table_serde (line 367) | fn test_table_serde() {
  function test_vec_string_serde (line 384) | fn test_vec_string_serde() {
  function test_send_receive_fds (line 396) | fn test_send_receive_fds() {
  function test_serde_via_socket (line 434) | fn test_serde_via_socket() {
  function test_send_fds_to_respects_configurable_timeout (line 469) | fn test_send_fds_to_respects_configurable_timeout() {
  function test_get_fds_from_respects_configurable_timeout (line 505) | fn test_get_fds_from_respects_configurable_timeout() {

FILE: pingora-core/src/services/background.rs
  type BackgroundService (line 37) | pub trait BackgroundService {
    method start_with_ready_notifier (line 45) | async fn start_with_ready_notifier(
    method start (line 57) | async fn start(&self, mut _shutdown: ShutdownWatch) {}
  type GenBackgroundService (line 61) | pub struct GenBackgroundService<A> {
  function new (line 72) | pub fn new(name: String, task: Arc<A>) -> Self {
  function task (line 81) | pub fn task(&self) -> Arc<A> {
  method start_service (line 94) | async fn start_service(
  method name (line 104) | fn name(&self) -> &str {
  method threads (line 108) | fn threads(&self) -> Option<usize> {
  function background_service (line 114) | pub fn background_service<SV>(name: &str, task: SV) -> GenBackgroundServ...

FILE: pingora-core/src/services/listening.rs
  type Service (line 44) | pub struct Service<A> {
  function new (line 56) | pub fn new(name: String, app_logic: A) -> Self {
  function with_listeners (line 69) | pub fn with_listeners(name: String, listeners: Listeners, app_logic: A) ...
  function set_connection_filter (line 106) | pub fn set_connection_filter(&mut self, filter: Arc<dyn ConnectionFilter...
  function set_connection_filter (line 112) | pub fn set_connection_filter(&mut self, _filter: Arc<dyn ConnectionFilte...
  function endpoints (line 115) | pub fn endpoints(&mut self) -> &mut Listeners {
  function add_tcp (line 122) | pub fn add_tcp(&mut self, addr: &str) {
  function add_tcp_with_settings (line 127) | pub fn add_tcp_with_settings(&mut self, addr: &str, sock_opt: TcpSocketO...
  function add_uds (line 136) | pub fn add_uds(&mut self, addr: &str, perm: Option<Permissions>) {
  function add_tls (line 141) | pub fn add_tls(&mut self, addr: &str, cert_path: &str, key_path: &str) -...
  function add_tls_with_settings (line 146) | pub fn add_tls_with_settings(
  function add_address (line 157) | pub fn add_address(&mut self, addr: ServerAddress) {
  function app_logic (line 162) | pub fn app_logic(&self) -> Option<&A> {
  function app_logic_mut (line 167) | pub fn app_logic_mut(&mut self) -> Option<&mut A> {
  function handle_event (line 173) | pub async fn handle_event(event: Stream, app_logic: Arc<A>, shutdown: Sh...
  function run_endpoint (line 184) | async fn run_endpoint(
  method start_service (line 261) | async fn start_service(
  method name (line 304) | fn name(&self) -> &str {
  method threads (line 308) | fn threads(&self) -> Option<usize> {
  function prometheus_http_service (line 319) | pub fn prometheus_http_service() -> Self {

FILE: pingora-core/src/services/mod.rs
  type ServiceReadyNotifier (line 61) | pub struct ServiceReadyNotifier {
    method new (line 78) | pub fn new(sender: watch::Sender<bool>) -> Self {
    method notify_ready (line 85) | pub fn notify_ready(self) {
  method drop (line 68) | fn drop(&mut self) {
  type ServiceReadyWatch (line 92) | pub type ServiceReadyWatch = watch::Receiver<bool>;
  type ServiceHandle (line 110) | pub struct ServiceHandle {
    method new (line 126) | pub(crate) fn new(
    method get_dependencies (line 141) | fn get_dependencies(&self) -> Vec<ServiceDependency> {
    method name (line 151) | pub fn name(&self) -> &str {
    method ready_watch (line 157) | pub(crate) fn ready_watch(&self) -> ServiceReadyWatch {
    method add_dependency (line 175) | pub fn add_dependency(&self, dependency: impl Borrow<ServiceHandle>) {
    method add_dependencies (line 202) | pub fn add_dependencies<'a, D>(&self, dependencies: impl IntoIterator<...
  type ServiceDependency (line 119) | pub(crate) struct ServiceDependency {
  type DependencyGraph (line 213) | pub(crate) struct DependencyGraph {
    method new (line 220) | pub(crate) fn new() -> Self {
    method add_node (line 227) | pub(crate) fn add_node(&mut self, name: String, ready_watch: ServiceRe...
    method add_dependency (line 234) | pub(crate) fn add_dependency(
    method topological_sort (line 259) | pub(crate) fn topological_sort(&self) -> Result<Vec<(NodeIndex, Servic...
    method get_dependencies (line 271) | pub(crate) fn get_dependencies(&self, service_id: NodeIndex) -> Vec<Se...
  method default (line 281) | fn default() -> Self {
  type ServiceWithDependents (line 287) | pub trait ServiceWithDependents: Send + Sync {
    method start_service (line 304) | async fn start_service(
    method name (line 315) | fn name(&self) -> &str;
    method threads (line 320) | fn threads(&self) -> Option<usize> {
    method on_startup_delay (line 332) | fn on_startup_delay(&self, time_waited: Duration) {
    method start_service (line 346) | async fn start_service(
    method name (line 366) | fn name(&self) -> &str {
    method threads (line 370) | fn threads(&self) -> Option<usize> {
    method on_startup_delay (line 374) | fn on_startup_delay(&self, time_waited: Duration) {
  type Service (line 381) | pub trait Service: Sync + Send {
    method start_service (line 394) | async fn start_service(
    method name (line 406) | fn name(&self) -> &str;
    method threads (line 411) | fn threads(&self) -> Option<usize> {
    method on_startup_delay (line 423) | fn on_startup_delay(&self, time_waited: Duration) {
  function test_service_handle_creation (line 437) | fn test_service_handle_creation() {
  function test_service_handle_add_dependency (line 455) | fn test_service_handle_add_dependency() {
  function test_service_handle_multiple_dependencies (line 490) | fn test_service_handle_multiple_dependencies() {
  function test_single_service_no_dependencies (line 531) | fn test_single_service_no_dependencies() {
  function test_simple_dependency_chain (line 542) | fn test_simple_dependency_chain() {
  function test_diamond_dependency (line 565) | fn test_diamond_dependency() {
  function test_missing_dependency (line 590) | fn test_missing_dependency() {
  function test_circular_dependency_self (line 602) | fn test_circular_dependency_self() {
  function test_circular_dependency_two_services (line 616) | fn test_circular_dependency_two_services() {
  function test_circular_dependency_three_services (line 634) | fn test_circular_dependency_three_services() {
  function test_complex_valid_graph (line 655) | fn test_complex_valid_graph() {

FILE: pingora-core/src/tls/mod.rs
  type AlpnError (line 50) | pub struct AlpnError;
    constant ALERT_FATAL (line 53) | pub const ALERT_FATAL: AlpnError = Self {};
    constant NOACK (line 56) | pub const NOACK: AlpnError = Self {};
  type ConnectConfiguration (line 60) | pub struct ConnectConfiguration;
    method set_use_server_name_indication (line 64) | pub fn set_use_server_name_indication(&mut self, _use_sni: bool) {
    method set_verify_hostname (line 69) | pub fn set_verify_hostname(&mut self, _verify_hostname: bool) {
    method into_ssl (line 74) | pub fn into_ssl(self, _domain: &str) -> Result<Ssl, ErrorStack> {
    method set_verify (line 79) | pub fn set_verify(&mut self, _mode: SslVerifyMode) {
    method set_alpn_protos (line 84) | pub fn set_alpn_protos(&mut self, _protocols: &[u8]) -> Result<(), Err...
    method param_mut (line 89) | pub fn param_mut(&mut self) -> &mut X509VerifyParamRef {
  type Error (line 96) | pub struct Error;
    method code (line 99) | pub fn code(&self) -> ErrorCode {
  type ErrorCode (line 106) | pub struct ErrorCode(i32);
    constant SSL (line 109) | pub const SSL: ErrorCode = Self(0);
  type NameType (line 113) | pub struct NameType;
    constant HOST_NAME (line 115) | pub const HOST_NAME: NameType = Self {};
  type Ssl (line 119) | pub struct Ssl;
    method new (line 122) | pub fn new(_ctx: &SslContextRef) -> Result<Ssl, ErrorStack> {
  type SslAcceptor (line 129) | pub struct SslAcceptor;
    method mozilla_intermediate_v5 (line 133) | pub fn mozilla_intermediate_v5(
  type SslAcceptorBuilder (line 141) | pub struct SslAcceptorBuilder;
    method build (line 144) | pub fn build(self) -> SslAcceptor {
    method set_alpn_select_callback (line 150) | pub fn set_alpn_select_callback<F>(&mut self, _callback: F)
    method set_certificate_chain_file (line 161) | pub fn set_certificate_chain_file<P: AsRef<std::path::Path>>(
    method set_private_key_file (line 169) | pub fn set_private_key_file<P: AsRef<std::path::Path>>(
    method set_max_proto_version (line 178) | pub fn set_max_proto_version(
  type SslCipherRef (line 187) | pub struct SslCipherRef;
    method name (line 190) | pub fn name(&self) -> &'static str {
  type SslConnector (line 196) | pub struct SslConnector;
    method builder (line 199) | pub fn builder(_method: SslMethod) -> Result<SslConnectorBuilder, Erro...
    method configure (line 204) | pub fn configure(&self) -> Result<ConnectConfiguration, ErrorStack> {
    method context (line 209) | pub fn context(&self) -> &SslContextRef {
  type SslConnectorBuilder (line 215) | pub struct SslConnectorBuilder;
    method build (line 218) | pub fn build(self) -> SslConnector {
    method set_cipher_list (line 223) | pub fn set_cipher_list(&mut self, _cipher_list: &str) -> Result<(), Er...
    method set_sigalgs_list (line 228) | pub fn set_sigalgs_list(&mut self, _sigalgs: &str) -> Result<(), Error...
    method set_min_proto_version (line 233) | pub fn set_min_proto_version(
    method set_max_proto_version (line 241) | pub fn set_max_proto_version(
    method set_default_verify_paths (line 249) | pub fn set_default_verify_paths(&mut self) -> Result<(), ErrorStack> {
    method set_ca_file (line 254) | pub fn set_ca_file<P: AsRef<std::path::Path>>(
    method set_certificate_file (line 262) | pub fn set_certificate_file<P: AsRef<std::path::Path>>(
    method set_private_key_file (line 271) | pub fn set_private_key_file<P: AsRef<std::path::Path>>(
    method set_keylog_callback (line 280) | pub fn set_keylog_callback<F>(&mut self, _callback: F)
  type SslContext (line 289) | pub struct SslContext;
    method builder (line 292) | pub fn builder(_method: SslMethod) -> Result<SslContextBuilder, ErrorS...
  type SslContextBuilder (line 299) | pub struct SslContextBuilder;
    method build (line 302) | pub fn build(self) -> SslContext {
  type SslContextRef (line 308) | pub struct SslContextRef;
  type SslFiletype (line 311) | pub struct SslFiletype;
    constant PEM (line 314) | pub const PEM: SslFiletype = Self {};
  type SslMethod (line 318) | pub struct SslMethod;
    method tls (line 321) | pub fn tls() -> SslMethod {
  type SslRef (line 327) | pub struct SslRef;
    method set_verify (line 330) | pub fn set_verify(&mut self, _mode: SslVerifyMode) {
    method current_cipher (line 335) | pub fn current_cipher(&self) -> Option<&SslCipherRef> {
    method set_hostname (line 340) | pub fn set_hostname(&mut self, _hostname: &str) -> Result<(), ErrorSta...
    method peer_certificate (line 345) | pub fn peer_certificate(&self) -> Option<X509> {
    method verify_result (line 350) | pub fn verify_result(&self) -> X509VerifyResult {
    method version_str (line 355) | pub fn version_str(&self) -> &'static str {
    method selected_alpn_protocol (line 360) | pub fn selected_alpn_protocol(&self) -> Option<&[u8]> {
    method servername (line 365) | pub fn servername(&self, _type_: NameType) -> Option<&str> {
  type SslVerifyMode (line 371) | pub struct SslVerifyMode;
    constant PEER (line 374) | pub const PEER: Self = Self {};
    constant NONE (line 377) | pub const NONE: Self = Self {};
  type SslVersion (line 381) | pub struct SslVersion;
    constant TLS1 (line 384) | pub const TLS1: SslVersion = Self {};
    constant TLS1_2 (line 387) | pub const TLS1_2: SslVersion = Self {};
    constant TLS1_3 (line 390) | pub const TLS1_3: SslVersion = Self {};
  function select_next_proto (line 395) | pub fn select_next_proto<'a>(_server: &[u8], _client: &'a [u8]) -> Optio...
  constant X509_V_OK (line 401) | pub const X509_V_OK: i32 = 0;
  constant X509_V_ERR_INVALID_CALL (line 402) | pub const X509_V_ERR_INVALID_CALL: i32 = 69;
  type ErrorStack (line 410) | pub struct ErrorStack;
    method get (line 415) | pub fn get() -> ErrorStack {
    method errors (line 420) | pub fn errors(&self) -> &[Error] {
  type X509 (line 434) | pub struct X509;
    method from_pem (line 438) | pub fn from_pem(_pem: &[u8]) -> Result<X509, ErrorStack> {
  type X509NameEntries (line 444) | pub struct X509NameEntries<'a> {
  type Item (line 448) | type Item = &'a X509NameEntryRef;
  method next (line 449) | fn next(&mut self) -> Option<&'a X509NameEntryRef> {
  type X509NameEntryRef (line 455) | pub struct X509NameEntryRef;
    method data (line 457) | pub fn data(&self) -> &Asn1StringRef {
  type X509NameRef (line 463) | pub struct X509NameRef;
    method entries_by_nid (line 466) | pub fn entries_by_nid(&self, _nid: Nid) -> X509NameEntries<'_> {
  type X509Ref (line 472) | pub struct X509Ref;
    method subject_name (line 475) | pub fn subject_name(&self) -> &X509NameRef {
    method digest (line 480) | pub fn digest(&self, _hash_type: MessageDigest) -> Result<DigestBytes,...
    method not_after (line 485) | pub fn not_after(&self) -> &Asn1TimeRef {
    method serial_number (line 490) | pub fn serial_number(&self) -> &Asn1IntegerRef {
  type X509VerifyResult (line 496) | pub struct X509VerifyResult;
    method as_raw (line 499) | pub fn as_raw(&self) -> i32 {
  type X509StoreBuilder (line 509) | pub struct X509StoreBuilder;
    method new (line 512) | pub fn new() -> Result<X509StoreBuilder, ErrorStack> {
    method build (line 517) | pub fn build(self) -> X509Store {
    method add_cert (line 522) | pub fn add_cert(&mut self, _cert: X509) -> Result<(), ErrorStack> {
  type X509Store (line 528) | pub struct X509Store;
  type X509StoreRef (line 532) | pub struct X509StoreRef;
  type X509VerifyParamRef (line 537) | pub struct X509VerifyParamRef;
  type Nid (line 543) | pub struct Nid;
    constant COMMONNAME (line 545) | pub const COMMONNAME: Nid = Self {};
    constant ORGANIZATIONNAME (line 546) | pub const ORGANIZATIONNAME: Nid = Self {};
    constant ORGANIZATIONALUNITNAME (line 547) | pub const ORGANIZATIONALUNITNAME: Nid = Self {};
  type PKey (line 556) | pub struct PKey<T> {
  type Target (line 560) | type Target = PKeyRef<T>;
  function deref (line 561) | fn deref(&self) -> &PKeyRef<T> {
  function deref_mut (line 566) | fn deref_mut(&mut self) -> &mut PKeyRef<T> {
  function private_key_from_pem (line 571) | pub fn private_key_from_pem(_pem: &[u8]) -> Result<PKey<Private>, ErrorS...
  type PKeyRef (line 577) | pub struct PKeyRef<T> {
  type Private (line 583) | pub enum Private {}
  type HasPrivate (line 587) | pub unsafe trait HasPrivate {}
  type MessageDigest (line 592) | pub struct MessageDigest;
    method sha256 (line 594) | pub fn sha256() -> MessageDigest {
  type DigestBytes (line 600) | pub struct DigestBytes;
    method as_ref (line 602) | fn as_ref(&self) -> &[u8] {
  type Asn1IntegerRef (line 613) | pub struct Asn1IntegerRef;
    method to_bn (line 616) | pub fn to_bn(&self) -> Result<BigNum, ErrorStack> {
  type Asn1StringRef (line 622) | pub struct Asn1StringRef;
    method as_utf8 (line 624) | pub fn as_utf8(&self) -> Result<&str, ErrorStack> {
  type Asn1TimeRef (line 630) | pub struct Asn1TimeRef;
  type BigNum (line 638) | pub struct BigNum;
    method to_hex_str (line 641) | pub fn to_hex_str(&self) -> Result<&str, ErrorStack> {
  function add_host (line 656) | pub fn add_host(_verify_param: &mut X509VerifyParamRef, _host: &str) -> ...
  function ssl_set_verify_cert_store (line 661) | pub fn ssl_set_verify_cert_store(
  function ssl_use_certificate (line 669) | pub fn ssl_use_certificate(_ssl: &mut SslRef, _cert: &X509Ref) -> Result...
  function ssl_use_private_key (line 674) | pub fn ssl_use_private_key<T>(_ssl: &mut SslRef, _key: &PKeyRef<T>) -> R...
  function clear_error_stack (line 682) | pub fn clear_error_stack() {}
  function ssl_from_acceptor (line 685) | pub fn ssl_from_acceptor(_acceptor: &SslAcceptor) -> Result<Ssl, ErrorSt...
  function suspend_when_need_ssl_cert (line 690) | pub fn suspend_when_need_ssl_cert(_ssl: &mut SslRef) {
  function unblock_ssl_cert (line 695) | pub fn unblock_ssl_cert(_ssl: &mut SslRef) {
  function is_suspended_for_cert (line 700) | pub fn is_suspended_for_cert(_error: &super::ssl::Error) -> bool {
  function ssl_add_chain_cert (line 705) | pub fn ssl_add_chain_cert(_ssl: &mut SslRef, _cert: &X509Ref) -> Result<...
  function ssl_set_renegotiate_mode_freely (line 710) | pub fn ssl_set_renegotiate_mode_freely(_ssl: &mut SslRef) {}
  function ssl_set_groups_list (line 713) | pub fn ssl_set_groups_list(_ssl: &mut SslRef, _groups: &str) -> Result<(...
  function ssl_use_second_key_share (line 718) | pub fn ssl_use_second_key_share(_ssl: &mut SslRef, _enabled: bool) {}
  function ssl_mut (line 722) | pub unsafe fn ssl_mut(_ssl: &SslRef) -> &mut SslRef {
  type SslStream (line 737) | pub struct SslStream<S> {
  function new (line 742) | pub fn new(_ssl: Ssl, _stream: S) -> Result<Self, ErrorStack> {
  function connect (line 747) | pub async fn connect(self: Pin<&mut Self>) -> Result<(), Error> {
  function accept (line 752) | pub async fn accept(self: Pin<&mut Self>) -> Result<(), Error> {
  function ssl (line 757) | pub fn ssl(&self) -> &SslRef {
  function get_ref (line 762) | pub fn get_ref(&self) -> &S {
  function get_mut (line 767) | pub fn get_mut(&mut self) -> &mut S {
  method poll_read (line 775) | fn poll_read(
  method poll_write (line 787) | fn poll_write(
  method poll_flush (line 795) | fn poll_flush(self: Pin<&mut Self>, _ctx: &mut Context<'_>) -> Poll<std:...
  method poll_shutdown (line 799) | fn poll_shutdown(

FILE: pingora-core/src/upstreams/peer.rs
  type ProxyDigestUserDataHook (line 58) | pub type ProxyDigestUserDataHook = Arc<
  type Tracing (line 69) | pub trait Tracing: Send + Sync + std::fmt::Debug {
    method on_connected (line 71) | fn on_connected(&self);
    method on_disconnected (line 73) | fn on_disconnected(&self);
    method boxed_clone (line 75) | fn boxed_clone(&self) -> Box<dyn Tracing>;
  type Tracer (line 80) | pub struct Tracer(pub Box<dyn Tracing>);
  method clone (line 83) | fn clone(&self) -> Self {
  type Peer (line 90) | pub trait Peer: Display + Clone {
    method address (line 92) | fn address(&self) -> &SocketAddr;
    method tls (line 94) | fn tls(&self) -> bool;
    method sni (line 96) | fn sni(&self) -> &str;
    method reuse_hash (line 101) | fn reuse_hash(&self) -> u64;
    method get_proxy (line 103) | fn get_proxy(&self) -> Option<&Proxy> {
    method get_peer_options (line 109) | fn get_peer_options(&self) -> Option<&PeerOptions> {
    method get_mut_peer_options (line 113) | fn get_mut_peer_options(&mut self) -> Option<&mut PeerOptions> {
    method verify_cert (line 117) | fn verify_cert(&self) -> bool {
    method verify_hostname (line 124) | fn verify_hostname(&self) -> bool {
    method use_system_certs (line 132) | fn use_system_certs(&self) -> bool {
    method alternative_cn (line 142) | fn alternative_cn(&self) -> Option<&String> {
    method bind_to (line 149) | fn bind_to(&self) -> Option<&BindTo> {
    method connection_timeout (line 156) | fn connection_timeout(&self) -> Option<Duration> {
    method total_connection_timeout (line 163) | fn total_connection_timeout(&self) -> Option<Duration> {
    method idle_timeout (line 171) | fn idle_timeout(&self) -> Option<Duration> {
    method get_alpn (line 176) | fn get_alpn(&self) -> Option<&ALPN> {
    method get_ca (line 183) | fn get_ca(&self) -> Option<&Arc<CaType>> {
    method get_client_cert_key (line 191) | fn get_client_cert_key(&self) -> Option<&Arc<CertKey>> {
    method get_psk (line 199) | fn get_psk(&self) -> Option<&Arc<PskType>> {
    method get_s2n_security_policy (line 211) | fn get_s2n_security_policy(&self) -> Option<&S2NPolicy> {
    method get_max_blinding_delay (line 222) | fn get_max_blinding_delay(&self) -> Option<u32> {
    method tcp_keepalive (line 230) | fn tcp_keepalive(&self) -> Option<&TcpKeepalive> {
    method h2_ping_interval (line 236) | fn h2_ping_interval(&self) -> Option<Duration> {
    method tcp_recv_buf (line 241) | fn tcp_recv_buf(&self) -> Option<usize> {
    method dscp (line 247) | fn dscp(&self) -> Option<u8> {
    method tcp_fast_open (line 252) | fn tcp_fast_open(&self) -> bool {
    method matches_fd (line 259) | fn matches_fd<V: AsRawFd>(&self, fd: V) -> bool {
    method matches_sock (line 264) | fn matches_sock<V: AsRawSocket>(&self, sock: V) -> bool {
    method get_tracer (line 269) | fn get_tracer(&self) -> Option<Tracer> {
    method upstream_tcp_sock_tweak_hook (line 276) | fn upstream_tcp_sock_tweak_hook(
    method proxy_digest_user_data_hook (line 286) | fn proxy_digest_user_data_hook(&self) -> Option<&ProxyDigestUserDataHo...
    method upstream_tls_handshake_complete_hook (line 301) | fn upstream_tls_handshake_complete_hook(&self) -> Option<&HandshakeCom...
    method address (line 349) | fn address(&self) -> &SocketAddr {
    method tls (line 353) | fn tls(&self) -> bool {
    method bind_to (line 357) | fn bind_to(&self) -> Option<&BindTo> {
    method sni (line 361) | fn sni(&self) -> &str {
    method reuse_hash (line 366) | fn reuse_hash(&self) -> u64 {
    method get_peer_options (line 372) | fn get_peer_options(&self) -> Option<&PeerOptions> {
    method address (line 708) | fn address(&self) -> &SocketAddr {
    method tls (line 712) | fn tls(&self) -> bool {
    method sni (line 716) | fn sni(&self) -> &str {
    method reuse_hash (line 721) | fn reuse_hash(&self) -> u64 {
    method get_peer_options (line 725) | fn get_peer_options(&self) -> Option<&PeerOptions> {
    method get_mut_peer_options (line 729) | fn get_mut_peer_options(&mut self) -> Option<&mut PeerOptions> {
    method get_proxy (line 733) | fn get_proxy(&self) -> Option<&Proxy> {
    method matches_fd (line 738) | fn matches_fd<V: AsRawFd>(&self, fd: V) -> bool {
    method matches_sock (line 747) | fn matches_sock<V: AsRawSocket>(&self, sock: V) -> bool {
    method get_client_cert_key (line 757) | fn get_client_cert_key(&self) -> Option<&Arc<CertKey>> {
    method get_tracer (line 761) | fn get_tracer(&self) -> Option<Tracer> {
  type BasicPeer (line 310) | pub struct BasicPeer {
    method new (line 318) | pub fn new(address: &str) -> Self {
    method new_uds (line 325) | pub fn new_uds<P: AsRef<Path>>(path: P) -> Result<Self> {
    method new_from_sockaddr (line 333) | fn new_from_sockaddr(sockaddr: SocketAddr) -> Self {
  method fmt (line 343) | fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
  type Scheme (line 379) | pub enum Scheme {
    method from_tls_bool (line 394) | pub fn from_tls_bool(tls: bool) -> Self {
  method fmt (line 385) | fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
  type PeerOptions (line 409) | pub struct PeerOptions {
    method new (line 471) | pub fn new() -> Self {
    method set_http_version (line 512) | pub fn set_http_version(&mut self, max: u8, min: u8) {
  method fmt (line 518) | fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
  type HttpPeer (line 578) | pub struct HttpPeer {
    method is_tls (line 592) | pub fn is_tls(&self) -> bool {
    method new_from_sockaddr (line 599) | fn new_from_sockaddr(address: SocketAddr, tls: bool, sni: String) -> S...
    method new (line 612) | pub fn new<A: ToInetSocketAddrs>(address: A, tls: bool, sni: String) -...
    method new_uds (line 620) | pub fn new_uds(path: &str, tls: bool, sni: String) -> Result<Self> {
    method new_proxy (line 629) | pub fn new_proxy(
    method new_mtls (line 654) | pub fn new_mtls<A: ToInetSocketAddrs>(
    method peer_hash (line 664) | fn peer_hash(&self) -> u64 {
  method hash (line 672) | fn hash<H: Hasher>(&self, state: &mut H) {
  method fmt (line 692) | fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
  type Proxy (line 768) | pub struct Proxy {
  method fmt (line 776) | fn fmt(&self, f: &mut Formatter) -> FmtResult {

FILE: pingora-core/src/utils/mod.rs
  type BufRef (line 33) | pub struct BufRef(pub usize, pub usize);
    method get (line 37) | pub fn get<'a>(&self, buf: &'a [u8]) -> &'a [u8] {
    method get_bytes (line 42) | pub fn get_bytes(&self, buf: &Bytes) -> Bytes {
    method len (line 47) | pub fn len(&self) -> usize {
    method is_empty (line 52) | pub fn is_empty(&self) -> bool {
    method new (line 60) | pub fn new(start: usize, len: usize) -> Self {
  type KVRef (line 67) | pub struct KVRef {
    method get_name (line 74) | pub fn get_name<'a>(&self, buf: &'a [u8]) -> &'a [u8] {
    method get_value (line 79) | pub fn get_value<'a>(&self, buf: &'a [u8]) -> &'a [u8] {
    method get_name_bytes (line 84) | pub fn get_name_bytes(&self, buf: &Bytes) -> Bytes {
    method get_value_bytes (line 89) | pub fn get_value_bytes(&self, buf: &Bytes) -> Bytes {
    method new (line 94) | pub fn new(name_s: usize, name_len: usize, value_s: usize, value_len: ...
    method value (line 102) | pub fn value(&self) -> &BufRef {
  constant EMPTY_KV_REF (line 108) | pub const EMPTY_KV_REF: KVRef = KVRef {

FILE: pingora-core/src/utils/tls/boringssl_openssl.rs
  function get_subject_name (line 20) | fn get_subject_name(cert: &X509, name_type: Nid) -> Option<String> {
  function get_organization (line 33) | pub fn get_organization(cert: &X509) -> Option<String> {
  function get_common_name (line 38) | pub fn get_common_name(cert: &X509) -> Option<String> {
  function get_organization_unit (line 43) | pub fn get_organization_unit(cert: &X509) -> Option<String> {
  function get_serial (line 48) | pub fn get_serial(cert: &X509) -> Result<String> {
  type CertKey (line 62) | pub struct CertKey {
    method new (line 69) | pub fn new(certificates: Vec<X509>, key: PKey<Private>) -> CertKey {
    method leaf (line 79) | pub fn leaf(&self) -> &X509 {
    method key (line 85) | pub fn key(&self) -> &PKey<Private> {
    method intermediates (line 90) | pub fn intermediates(&self) -> &[X509] {
    method organization (line 98) | pub fn organization(&self) -> Option<String> {
    method serial (line 103) | pub fn serial(&self) -> Result<String> {
    method fmt (line 120) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method fmt (line 128) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method hash (line 109) | fn hash<H: Hasher>(&self, state: &mut H) {

FILE: pingora-core/src/utils/tls/rustls.rs
  function get_organization_serial (line 23) | pub fn get_organization_serial(x509cert: &WrappedX509) -> Result<(Option...
  function get_organization_serial_x509 (line 28) | fn get_organization_serial_x509(
  function get_serial (line 37) | pub fn get_serial(x509cert: &WrappedX509) -> Result<String> {
  function get_organization (line 43) | pub fn get_organization(x509cert: &WrappedX509) -> Option<String> {
  function get_organization_x509 (line 49) | pub fn get_organization_x509(x509cert: &X509Certificate<'_>) -> Option<S...
  function get_organization_serial_bytes (line 60) | pub fn get_organization_serial_bytes(cert: &[u8]) -> Result<(Option<Stri...
  function get_organization_unit (line 69) | pub fn get_organization_unit(x509cert: &WrappedX509) -> Option<String> {
  function get_common_name (line 81) | pub fn get_common_name(x509cert: &WrappedX509) -> Option<String> {
  function get_not_after (line 93) | pub fn get_not_after(x509cert: &WrappedX509) -> String {
  type CertKey (line 99) | pub struct CertKey {
    method new (line 138) | pub fn new(certificates: Vec<Vec<u8>>, key: Vec<u8>) -> CertKey {
    method leaf (line 154) | pub fn leaf(&self) -> &WrappedX509 {
    method key (line 160) | pub fn key(&self) -> &Vec<u8> {
    method intermediates (line 165) | pub fn intermediates(&self) -> Vec<&WrappedX509> {
    method organization (line 170) | pub fn organization(&self) -> Option<String> {
    method serial (line 175) | pub fn serial(&self) -> String {
    method fmt (line 188) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method fmt (line 196) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type WrappedX509 (line 106) | pub struct WrappedX509 {
    method not_after (line 181) | pub fn not_after(&self) -> String {
  function parse_x509 (line 114) | fn parse_x509<C>(raw_cert: &C) -> X509Certificate<'_>
  method clone (line 124) | fn clone(&self) -> Self {
  method hash (line 211) | fn hash<H: Hasher>(&self, state: &mut H) {
  function from (line 221) | fn from(value: &'a WrappedX509) -> Self {

FILE: pingora-core/src/utils/tls/s2n.rs
  function get_organization_serial_x509 (line 23) | fn get_organization_serial_x509(
  function get_serial (line 32) | pub fn get_serial(x509cert: &WrappedX509) -> Result<String> {
  function get_organization (line 38) | pub fn get_organization(x509cert: &WrappedX509) -> Option<String> {
  function get_organization_x509 (line 44) | pub fn get_organization_x509(x509cert: &X509Certificate<'_>) -> Option<S...
  function get_organization_serial_bytes (line 55) | pub fn get_organization_serial_bytes(cert: &[u8]) -> Result<(Option<Stri...
  function get_organization_unit (line 64) | pub fn get_organization_unit(x509cert: &WrappedX509) -> Option<String> {
  function get_common_name (line 76) | pub fn get_common_name(x509cert: &WrappedX509) -> Option<String> {
  function get_not_after (line 88) | pub fn get_not_after(x509cert: &WrappedX509) -> String {
  type CertKey (line 94) | pub struct CertKey {
    method new (line 101) | pub fn new(pem_bytes: Vec<u8>, key: Vec<u8>) -> CertKey {
    method leaf (line 112) | pub fn leaf(&self) -> &WrappedX509 {
    method key (line 118) | pub fn key(&self) -> &Vec<u8> {
    method intermediates (line 123) | pub fn intermediates(&self) -> Vec<&WrappedX509> {
    method organization (line 128) | pub fn organization(&self) -> Option<String> {
    method serial (line 133) | pub fn serial(&self) -> String {
    method raw_pem (line 137) | pub fn raw_pem(&self) -> &[u8] {
    method fmt (line 191) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method fmt (line 199) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type X509Pem (line 143) | pub struct X509Pem {
    method new (line 149) | pub fn new(raw_pem: Vec<u8>) -> Self {
    method iter (line 159) | pub fn iter(&self) -> std::slice::Iter<'_, WrappedX509> {
  function parse_x509 (line 164) | fn parse_x509<C>(raw_cert: &C) -> X509Certificate<'_>
  type WrappedX509 (line 175) | pub struct WrappedX509 {
    method not_after (line 184) | pub fn not_after(&self) -> String {
  method hash (line 214) | fn hash<H: Hasher>(&self, state: &mut H) {
  method hash (line 224) | fn hash<H: Hasher>(&self, state: &mut H) {

FILE: pingora-core/tests/server_phase_fastshutdown.rs
  function test_server_execution_phase_monitor_fast_shutdown (line 22) | fn test_server_execution_phase_monitor_fast_shutdown() {

FILE: pingora-core/tests/server_phase_gracefulshutdown.rs
  function test_server_execution_phase_monitor_graceful_shutdown (line 22) | fn test_server_execution_phase_monitor_graceful_shutdown() {

FILE: pingora-core/tests/test_basic.rs
  function test_http (line 21) | async fn test_http() {
  function test_https_http2 (line 29) | async fn test_https_http2() {
  function test_uds (line 55) | async fn test_uds() {

FILE: pingora-core/tests/utils/mod.rs
  type EchoApp (line 34) | pub struct EchoApp;
  method response (line 38) | async fn response(&self, http_stream: &mut ServerSession) -> Response<Ve...
  type MyServer (line 65) | pub struct MyServer {
    method start (line 97) | pub fn start() -> Self {
  function entry_point (line 71) | fn entry_point(opt: Option<Opt>) {
  function init (line 116) | pub fn init() {

FILE: pingora-error/src/immut_str.rs
  type ImmutStr (line 20) | pub enum ImmutStr {
    method as_str (line 27) | pub fn as_str(&self) -> &str {
    method is_owned (line 34) | pub fn is_owned(&self) -> bool {
    method fmt (line 43) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 49) | fn from(s: &'static str) -> Self {
    method from (line 55) | fn from(s: String) -> Self {
  function test_static_vs_owned (line 65) | fn test_static_vs_owned() {

FILE: pingora-error/src/lib.rs
  type BError (line 27) | pub type BError = Box<Error>;
  type Result (line 29) | pub type Result<T, E = BError> = StdResult<T, E>;
  type Error (line 33) | pub struct Error {
    method create (line 203) | pub fn create(
    method do_new (line 228) | fn do_new(e: ErrorType, s: ErrorSource) -> BError {
    method new (line 234) | pub fn new(e: ErrorType) -> BError {
    method because (line 256) | pub fn because<S: Into<ImmutStr>, E: Into<Box<dyn ErrorTrait + Send + ...
    method e_because (line 271) | pub fn e_because<T, S: Into<ImmutStr>, E: Into<Box<dyn ErrorTrait + Se...
    method explain (line 281) | pub fn explain<S: Into<ImmutStr>>(e: ErrorType, context: S) -> BError {
    method e_explain (line 287) | pub fn e_explain<T, S: Into<ImmutStr>>(e: ErrorType, context: S) -> Re...
    method new_up (line 294) | pub fn new_up(e: ErrorType) -> BError {
    method new_down (line 299) | pub fn new_down(e: ErrorType) -> BError {
    method new_in (line 304) | pub fn new_in(e: ErrorType) -> BError {
    method new_str (line 310) | pub fn new_str(s: &'static str) -> BError {
    method err (line 316) | pub fn err<T>(e: ErrorType) -> Result<T> {
    method err_up (line 321) | pub fn err_up<T>(e: ErrorType) -> Result<T> {
    method err_down (line 326) | pub fn err_down<T>(e: ErrorType) -> Result<T> {
    method err_in (line 331) | pub fn err_in<T>(e: ErrorType) -> Result<T> {
    method etype (line 335) | pub fn etype(&self) -> &ErrorType {
    method esource (line 339) | pub fn esource(&self) -> &ErrorSource {
    method retry (line 343) | pub fn retry(&self) -> bool {
    method set_retry (line 347) | pub fn set_retry(&mut self, retry: bool) {
    method reason_str (line 351) | pub fn reason_str(&self) -> &str {
    method source_str (line 355) | pub fn source_str(&self) -> &str {
    method as_up (line 361) | pub fn as_up(&mut self) {
    method as_down (line 365) | pub fn as_down(&mut self) {
    method as_in (line 369) | pub fn as_in(&mut self) {
    method into_up (line 374) | pub fn into_up(mut self: BError) -> BError {
    method into_down (line 379) | pub fn into_down(mut self: BError) -> BError {
    method into_in (line 384) | pub fn into_in(mut self: BError) -> BError {
    method into_err (line 389) | pub fn into_err<T>(self: BError) -> Result<T> {
    method set_cause (line 393) | pub fn set_cause<C: Into<Box<dyn ErrorTrait + Send + Sync>>>(&mut self...
    method set_context (line 397) | pub fn set_context<T: Into<ImmutStr>>(&mut self, context: T) {
    method more_context (line 417) | pub fn more_context<T: Into<ImmutStr>>(self: BError, context: T) -> BE...
    method chain_display (line 427) | fn chain_display(&self, previous: Option<&Error>, f: &mut fmt::Formatt...
    method root_etype (line 451) | pub fn root_etype(&self) -> &ErrorType {
    method root_cause (line 459) | pub fn root_cause(&self) -> &(dyn ErrorTrait + Send + Sync + 'static) {
    method fmt (line 467) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ErrorSource (line 48) | pub enum ErrorSource {
    method as_str (line 91) | pub fn as_str(&self) -> &'static str {
  type RetryType (line 61) | pub enum RetryType {
    method decide_reuse (line 67) | pub fn decide_reuse(&mut self, reused: bool) {
    method retry (line 73) | pub fn retry(&self) -> bool {
    method from (line 84) | fn from(b: bool) -> Self {
  type ErrorType (line 103) | pub enum ErrorType {
    method new (line 152) | pub const fn new(name: &'static str) -> Self {
    method new_code (line 157) | pub const fn new_code(name: &'static str, code: u16) -> Self {
    method as_str (line 162) | pub fn as_str(&self) -> &'static str {
  type Context (line 475) | pub trait Context<T> {
    method err_context (line 479) | fn err_context<C: Into<ImmutStr>, F: FnOnce() -> C>(self, context: F) ...
  function err_context (line 483) | fn err_context<C: Into<ImmutStr>, F: FnOnce() -> C>(self, context: F) ->...
  type OrErr (line 489) | pub trait OrErr<T, E> {
    method or_err (line 493) | fn or_err(self, et: ErrorType, context: &'static str) -> Result<T, BEr...
    method or_err_with (line 498) | fn or_err_with<C: Into<ImmutStr>, F: FnOnce() -> C>(
    method explain_err (line 509) | fn explain_err<C: Into<ImmutStr>, F: FnOnce(E) -> C>(
    method or_fail (line 518) | fn or_fail(self) -> Result<T>
  function or_err (line 524) | fn or_err(self, et: ErrorType, context: &'static str) -> Result<T, BError>
  function or_err_with (line 531) | fn or_err_with<C: Into<ImmutStr>, F: FnOnce() -> C>(
  function explain_err (line 542) | fn explain_err<C: Into<ImmutStr>, F: FnOnce(E) -> C>(
  function or_fail (line 550) | fn or_fail(self) -> Result<T, BError>
  type OkOrErr (line 559) | pub trait OkOrErr<T> {
    method or_err (line 560) | fn or_err(self, et: ErrorType, context: &'static str) -> Result<T, BEr...
    method or_err_with (line 562) | fn or_err_with<C: Into<ImmutStr>, F: FnOnce() -> C>(
  function or_err (line 573) | fn or_err(self, et: ErrorType, context: &'static str) -> Result<T, BErro...
  function or_err_with (line 578) | fn or_err_with<C: Into<ImmutStr>, F: FnOnce() -> C>(
  function test_chain_of_error (line 592) | fn test_chain_of_error() {
  function test_error_context (line 609) | fn test_error_context() {
  function test_context_trait (line 616) | fn test_context_trait() {
  function test_cause_trait (line 626) | fn test_cause_trait() {
  function test_option_some_ok (line 636) | fn test_option_some_ok() {
  function test_option_none_err (line 646) | fn test_option_none_err() {
  function test_into (line 662) | fn test_into() {

FILE: pingora-header-serde/src/dict.rs
  function train (line 23) | pub fn train<P: AsRef<std::path::Path>>(dir_path: P) -> Vec<u8> {
  function gen_test_dict (line 37) | fn gen_test_dict() -> Vec<u8> {
  function gen_test_header (line 43) | fn gen_test_header() -> ResponseHeader {
  function test_ser_with_dict (line 61) | fn test_ser_with_dict() {
  function test_deserialize_with_dict (line 77) | fn test_deserialize_with_dict() {
  function test_ser_de_with_dict (line 94) | fn test_ser_de_with_dict() {

FILE: pingora-header-serde/src/lib.rs
  type HeaderSerde (line 39) | pub struct HeaderSerde {
    method new (line 54) | pub fn new(dict: Option<Vec<u8>>) -> Self {
    method serialize (line 75) | pub fn serialize(&self, header: &ResponseHeader) -> Result<Vec<u8>> {
    method deserialize (line 88) | pub fn deserialize(&self, data: &[u8]) -> Result<ResponseHeader> {
  constant MAX_HEADER_BUF_SIZE (line 45) | const MAX_HEADER_BUF_SIZE: usize = 128 * 1024;
  constant COMPRESS_LEVEL (line 47) | const COMPRESS_LEVEL: i32 = 3;
  type ZstdCompression (line 102) | enum ZstdCompression {
    method compress (line 113) | fn compress(&self, data: &[u8]) -> Result<Vec<u8>> {
    method decompress_to_buffer (line 124) | fn decompress_to_buffer(&self, source: &[u8], destination: &mut Vec<u8...
  function into_error (line 108) | fn into_error<S: Into<ImmutStr>>(e: &'static str, context: S) -> Box<Err...
  function get_frame_content_size (line 153) | fn get_frame_content_size(source: &[u8]) -> ImmutStr {
  constant CRLF (line 165) | const CRLF: &[u8; 2] = b"\r\n";
  function resp_header_to_buf (line 169) | fn resp_header_to_buf(resp: &ResponseHeader, buf: &mut Vec<u8>) -> usize {
  constant MAX_HEADERS (line 195) | const MAX_HEADERS: usize = 256;
  function buf_to_http_header (line 198) | fn buf_to_http_header(buf: &[u8]) -> Result<ResponseHeader> {
  function parsed_to_header (line 221) | fn parsed_to_header(parsed: &httparse::Response) -> Result<ResponseHeade...
  function test_ser_wo_dict (line 238) | fn test_ser_wo_dict() {
  function test_ser_de_no_dict (line 253) | fn test_ser_de_no_dict() {
  function test_no_headers (line 268) | fn test_no_headers() {
  function test_empty_header_wire_format (line 282) | fn test_empty_header_wire_format() {

FILE: pingora-header-serde/src/thread_zstd.rs
  type Compression (line 26) | pub struct Compression(CompressionInner);
    method new (line 31) | pub fn new() -> Self {
    method compress_to_buffer (line 35) | pub fn compress_to_buffer<C: zstd_safe::WriteBuf + ?Sized>(
    method compress (line 44) | pub fn compress(&self, data: &[u8], level: i32) -> Result<Vec<u8>, &'s...
    method decompress_to_buffer (line 50) | pub fn decompress_to_buffer<C: zstd_safe::WriteBuf + ?Sized>(
  type CompressionWithDict (line 59) | pub struct CompressionWithDict {
    method new (line 67) | pub fn new(dict: &[u8], compression_level: i32) -> Self {
    method compress_to_buffer (line 77) | pub fn compress_to_buffer<C: zstd_safe::WriteBuf + ?Sized>(
    method compress (line 86) | pub fn compress(&self, data: &[u8]) -> Result<Vec<u8>, &'static str> {
    method decompress_to_buffer (line 92) | pub fn decompress_to_buffer<C: zstd_safe::WriteBuf + ?Sized>(
  type CompressionInner (line 103) | struct CompressionInner {
    method new (line 109) | fn new() -> Self {
    method get_com_context (line 117) | fn get_com_context(&self) -> RefMut<'_, CCtx<'static>> {
    method get_de_context (line 124) | fn get_de_context(&self) -> RefMut<'_, DCtx<'static>> {
    method compress_to_buffer (line 130) | fn compress_to_buffer<C: zstd_safe::WriteBuf + ?Sized>(
    method decompress_to_buffer (line 141) | fn decompress_to_buffer<C: zstd_safe::WriteBuf + ?Sized>(
    method compress_to_buffer_using_dict (line 151) | fn compress_to_buffer_using_dict<C: zstd_safe::WriteBuf + ?Sized>(
    method decompress_to_buffer_using_dict (line 162) | pub fn decompress_to_buffer_using_dict<C: zstd_safe::WriteBuf + ?Sized>(
  function make_compressed_data_buffer (line 177) | fn make_compressed_data_buffer(uncompressed_len: usize) -> Vec<u8> {

FILE: pingora-header-serde/src/trainer.rs
  function main (line 19) | pub fn main() {

FILE: pingora-http/src/case_header_name.rs
  type CaseHeaderName (line 20) | pub struct CaseHeaderName(Bytes);
    method new (line 23) | pub fn new(name: String) -> Self {
    method as_slice (line 29) | pub fn as_slice(&self) -> &[u8] {
    method from_slice (line 33) | pub fn from_slice(buf: &[u8]) -> Self {
  type IntoCaseHeaderName (line 39) | pub trait IntoCaseHeaderName {
    method into_case_header_name (line 40) | fn into_case_header_name(self) -> CaseHeaderName;
    method into_case_header_name (line 44) | fn into_case_header_name(self) -> CaseHeaderName {
    method into_case_header_name (line 50) | fn into_case_header_name(self) -> CaseHeaderName {
    method into_case_header_name (line 56) | fn into_case_header_name(self) -> CaseHeaderName {
    method into_case_header_name (line 62) | fn into_case_header_name(self) -> CaseHeaderName {
    method into_case_header_name (line 68) | fn into_case_header_name(self) -> CaseHeaderName {
    method into_case_header_name (line 74) | fn into_case_header_name(self) -> CaseHeaderName {
  function titled_header_name (line 79) | fn titled_header_name(header_name: &HeaderName) -> Bytes {
  function titled_header_name_str (line 86) | pub(crate) fn titled_header_name_str(header_name: &HeaderName) -> Option...
  function test_case_header_name (line 113) | fn test_case_header_name() {

FILE: pingora-http/src/lib.rs
  type CaseMap (line 58) | type CaseMap = HMap<CaseHeaderName>;
  type HeaderNameVariant (line 60) | pub enum HeaderNameVariant<'a> {
  type RequestHeader (line 73) | pub struct RequestHeader {
    method as_ref (line 83) | fn as_ref(&self) -> &ReqParts {
    method new_no_case (line 103) | fn new_no_case(size_hint: Option<usize>) -> Self {
    method build (line 117) | pub fn build(
    method build_no_case (line 134) | pub fn build_no_case(
    method append_header (line 151) | pub fn append_header(
    method insert_header (line 171) | pub fn insert_header(
    method remove_header (line 188) | pub fn remove_header<'a, N: ?Sized>(&mut self, name: &'a N) -> Option<...
    method header_to_h1_wire (line 198) | pub fn header_to_h1_wire(&self, buf: &mut impl BufMut) {
    method case_header_iter (line 206) | pub fn case_header_iter(&self) -> impl Iterator<Item = (&CaseHeaderNam...
    method has_case (line 211) | pub fn has_case(&self) -> bool {
    method map (line 215) | pub fn map<F: FnMut(HeaderNameVariant, &HeaderValue) -> Result<()>>(
    method set_method (line 243) | pub fn set_method(&mut self, method: Method) {
    method set_uri (line 248) | pub fn set_uri(&mut self, uri: http::Uri) {
    method set_raw_path (line 259) | pub fn set_raw_path(&mut self, path: &[u8]) -> Result<()> {
    method set_send_end_stream (line 281) | pub fn set_send_end_stream(&mut self, send_end_stream: bool) {
    method send_end_stream (line 287) | pub fn send_end_stream(&self) -> Option<bool> {
    method raw_path (line 297) | pub fn raw_path(&self) -> &[u8] {
    method uri_file_extension (line 313) | pub fn uri_file_extension(&self) -> Option<&str> {
    method set_version (line 323) | pub fn set_version(&mut self, version: Version) {
    method as_owned_parts (line 328) | pub fn as_owned_parts(&self) -> ReqParts {
    method from (line 346) | fn from(parts: ReqParts) -> RequestHeader {
  type Target (line 89) | type Target = ReqParts;
  method deref (line 91) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 97) | fn deref_mut(&mut self) -> &mut Self::Target {
  method clone (line 334) | fn clone(&self) -> Self {
  method from (line 358) | fn from(resp: RequestHeader) -> ReqParts {
  type ResponseHeader (line 369) | pub struct ResponseHeader {
    method as_ref (line 378) | fn as_ref(&self) -> &RespParts {
    method from (line 409) | fn from(parts: RespParts) -> ResponseHeader {
    method new (line 431) | fn new(size_hint: Option<usize>) -> Self {
    method new_no_case (line 439) | fn new_no_case(size_hint: Option<usize>) -> Self {
    method build (line 450) | pub fn build(code: impl TryInto<StatusCode>, size_hint: Option<usize>)...
    method build_no_case (line 463) | pub fn build_no_case(code: impl TryInto<StatusCode>, size_hint: Option...
    method append_header (line 475) | pub fn append_header(
    method insert_header (line 495) | pub fn insert_header(
    method remove_header (line 512) | pub fn remove_header<'a, N: ?Sized>(&mut self, name: &'a N) -> Option<...
    method header_to_h1_wire (line 522) | pub fn header_to_h1_wire(&self, buf: &mut impl BufMut) {
    method case_header_iter (line 530) | pub fn case_header_iter(&self) -> impl Iterator<Item = (&CaseHeaderNam...
    method has_case (line 535) | pub fn has_case(&self) -> bool {
    method map (line 539) | pub fn map<F: FnMut(HeaderNameVariant, &HeaderValue) -> Result<()>>(
    method set_status (line 567) | pub fn set_status(&mut self, status: impl TryInto<StatusCode>) -> Resu...
    method set_version (line 575) | pub fn set_version(&mut self, version: Version) {
    method set_reason_phrase (line 580) | pub fn set_reason_phrase(&mut self, reason_phrase: Option<&str>) -> Re...
    method get_reason_phrase (line 594) | pub fn get_reason_phrase(&self) -> Option<&str> {
    method as_owned_parts (line 601) | pub fn as_owned_parts(&self) -> RespParts {
    method set_content_length (line 606) | pub fn set_content_length(&mut self, len: usize) -> Result<()> {
  type Target (line 384) | type Target = RespParts;
  method deref (line 386) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 392) | fn deref_mut(&mut self) -> &mut Self::Target {
  method clone (line 398) | fn clone(&self) -> Self {
  method from (line 419) | fn from(resp: ResponseHeader) -> RespParts {
  function from (line 425) | fn from(resp: Box<ResponseHeader>) -> Box<RespParts> {
  function clone_req_parts (line 611) | fn clone_req_parts(me: &ReqParts) -> ReqParts {
  function clone_resp_parts (line 625) | fn clone_resp_parts(me: &RespParts) -> RespParts {
  function http_header_map_upper_bound (line 642) | fn http_header_map_upper_bound(size_hint: Option<usize>) -> usize {
  function append_header_value (line 662) | fn append_header_value<T>(
  function insert_header_value (line 682) | fn insert_header_value<T>(
  function remove_header (line 703) | fn remove_header<'a, T, N: ?Sized>(
  function header_to_h1_wire (line 721) | fn header_to_h1_wire(key_map: Option<&CaseMap>, value_map: &HMap, buf: &...
  function case_header_iter (line 745) | fn case_header_iter<'a>(
  function header_map_upper_bound (line 766) | fn header_map_upper_bound() {
  function test_single_header (line 773) | fn test_single_header() {
  function test_single_header_no_case (line 812) | fn test_single_header_no_case() {
  function test_multiple_header (line 835) | fn test_multiple_header() {
  function test_invalid_path (line 915) | fn test_invalid_path() {
  function test_override_invalid_path (line 924) | fn test_override_invalid_path() {
  function test_reason_phrase (line 937) | fn test_reason_phrase() {
  function set_test_send_end_stream (line 956) | fn set_test_send_end_stream() {
  function set_test_set_content_length (line 975) | fn set_test_set_content_length() {

FILE: pingora-ketama/benches/memory.rs
  function buckets (line 6) | fn buckets() -> Vec<Bucket> {
  function main (line 19) | pub fn main() {

FILE: pingora-ketama/benches/simple.rs
  function buckets (line 13) | fn buckets() -> Vec<Bucket> {
  function random_string (line 23) | fn random_string() -> String {
  function criterion_benchmark (line 28) | pub fn criterion_benchmark(c: &mut Criterion) {

FILE: pingora-ketama/examples/health_aware_selector.rs
  type NodeHealthRepository (line 7) | struct NodeHealthRepository {
    method new (line 12) | fn new() -> Self {
    method set_node_health (line 18) | fn set_node_health(&mut self, node: SocketAddr, is_healthy: bool) {
    method node_is_healthy (line 22) | fn node_is_healthy(&self, node: &SocketAddr) -> bool {
  type HealthAwareNodeSelector (line 28) | struct HealthAwareNodeSelector<'a> {
  function new (line 35) | fn new(r: Continuum, tries: usize, nhr: &NodeHealthRepository) -> Health...
  function try_select (line 44) | fn try_select(&self, key: &str) -> Option<SocketAddr> {
  function main (line 62) | fn main() {

FILE: pingora-ketama/src/lib.rs
  constant DEFAULT_POINT_MULTIPLE (line 70) | pub const DEFAULT_POINT_MULTIPLE: u32 = 160;
  type Bucket (line 76) | pub struct Bucket {
    method new (line 94) | pub fn new(node: SocketAddr, weight: u32) -> Self {
  type PointV1 (line 103) | struct PointV1 {
    method new (line 123) | fn new(node: u32, hash: u32) -> Self {
  method cmp (line 111) | fn cmp(&self, other: &Self) -> Ordering {
  method partial_cmp (line 117) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  type PointV2 (line 143) | struct PointV2([u8; 6]);
    method new (line 147) | fn new(node: u16, hash: u32) -> Self {
    method hash (line 157) | fn hash(&self) -> u32 {
    method node (line 162) | fn node(&self) -> u16 {
  type Version (line 168) | pub enum Version {
    method point_multiple (line 176) | fn point_multiple(&self) -> u32 {
  type RingBuilder (line 185) | enum RingBuilder {
    method new (line 192) | fn new(version: Version, total_weight: u32) -> Self {
    method push (line 204) | fn push(&mut self, node: u16, hash: u32) {
    method sort (line 217) | fn sort(&mut self, addresses: &[SocketAddr]) {
  type VersionedRing (line 249) | enum VersionedRing {
    method from (line 240) | fn from(ring: RingBuilder) -> Self {
    method node_idx (line 257) | pub fn node_idx(&self, hash: u32) -> usize {
    method get (line 280) | pub fn get(&self, index: usize) -> Option<usize> {
    method len (line 288) | pub fn len(&self) -> usize {
  type Continuum (line 301) | pub struct Continuum {
    method new (line 307) | pub fn new(buckets: &[Bucket]) -> Self {
    method new_with_version (line 312) | pub fn new_with_version(buckets: &[Bucket], version: Version) -> Self {
    method node_idx (line 371) | pub fn node_idx(&self, input: &[u8]) -> usize {
    method node (line 377) | pub fn node(&self, hash_key: &[u8]) -> Option<SocketAddr> {
    method node_iter (line 387) | pub fn node_iter(&self, hash_key: &[u8]) -> NodeIterator<'_> {
    method get_addr (line 394) | pub fn get_addr(&self, idx: &mut usize) -> Option<&SocketAddr> {
  type NodeIterator (line 405) | pub struct NodeIterator<'a> {
  type Item (line 411) | type Item = &'a SocketAddr;
  method next (line 413) | fn next(&mut self) -> Option<Self::Item> {
  function get_sockaddr (line 425) | fn get_sockaddr(ip: &str) -> SocketAddr {
  function consistency_after_adding_host (line 430) | fn consistency_after_adding_host() {
  function matches_nginx_sample (line 452) | fn matches_nginx_sample() {
  function matches_nginx_sample_data (line 484) | fn matches_nginx_sample_data() {
  function node_iter (line 525) | fn node_iter() {
  function test_empty (line 579) | fn test_empty() {
  function test_ipv6_ring (line 590) | fn test_ipv6_ring() {

FILE: pingora-ketama/tests/backwards_compat.rs
  function random_socket_addr (line 23) | fn random_socket_addr() -> SocketAddr {
  function random_string (line 36) | fn random_string(len: usize) -> String {
  function test_v1_to_old_version (line 50) | fn test_v1_to_old_version() {
  function test_v2_to_old_version (line 72) | fn test_v2_to_old_version() {

FILE: pingora-ketama/tests/old_version/mod.rs
  type Bucket (line 29) | pub struct Bucket {
    method new (line 47) | pub fn new(node: SocketAddr, weight: u32) -> Self {
  type Point (line 56) | struct Point {
    method new (line 76) | fn new(node: u32, hash: u32) -> Self {
  method cmp (line 64) | fn cmp(&self, other: &Self) -> Ordering {
  method partial_cmp (line 70) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  type Continuum (line 85) | pub struct Continuum {
    method new (line 92) | pub fn new(buckets: &[Bucket]) -> Self {
    method node_idx (line 154) | pub fn node_idx(&self, input: &[u8]) -> usize {
    method node (line 173) | pub fn node(&self, hash_key: &[u8]) -> Option<SocketAddr> {

FILE: pingora-limits/benches/benchmark.rs
  type Counter (line 31) | trait Counter {
    method incr (line 32) | fn incr(&self, key: u32, value: usize);
    method name (line 33) | fn name() -> &'static str;
    method incr (line 39) | fn incr(&self, key: u32, value: usize) {
    method name (line 48) | fn name() -> &'static str {
    method incr (line 56) | fn incr(&self, key: u32, value: usize) {
    method name (line 64) | fn name() -> &'static str {
    method incr (line 70) | fn incr(&self, key: u32, value: usize) {
    method name (line 74) | fn name() -> &'static str {
  type NaiveCounter (line 37) | struct NaiveCounter(Mutex<HashMap<u32, usize>>);
  type OptimizedCounter (line 54) | struct OptimizedCounter(DashMap<u32, AtomicUsize, RandomState>);
  function run_bench (line 79) | fn run_bench<T: Counter>(
  function run_threaded_bench (line 100) | fn run_threaded_bench<T: Counter + Send + Sync + 'static>(
  function main (line 169) | fn main() {

FILE: pingora-limits/src/estimator.rs
  type Estimator (line 26) | pub struct Estimator {
    method new (line 32) | pub fn new(hashes: usize, slots: usize) -> Self {
    method incr (line 45) | pub fn incr<T: Hash>(&self, key: T, value: isize) -> isize {
    method decr (line 58) | pub fn decr<T: Hash>(&self, key: T, value: isize) {
    method get (line 67) | pub fn get<T: Hash>(&self, key: T) -> isize {
    method reset (line 79) | pub fn reset(&self) {
  function incr (line 92) | fn incr() {
  function desc (line 105) | fn desc() {
  function get (line 116) | fn get() {
  function reset (line 127) | fn reset() {

FILE: pingora-limits/src/inflight.rs
  type Inflight (line 25) | pub struct Inflight {
    method new (line 39) | pub fn new() -> Self {
    method incr (line 48) | pub fn incr<T: Hash>(&self, key: T, value: isize) -> (Guard, isize) {
  constant HASHES (line 34) | const HASHES: usize = 4;
  constant SLOTS (line 35) | const SLOTS: usize = 8192;
  type Guard (line 60) | pub struct Guard {
    method incr (line 69) | pub fn incr(&self) -> isize {
    method get (line 74) | pub fn get(&self) -> isize {
    method fmt (line 86) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method drop (line 80) | fn drop(&mut self) {
  function inflight_count (line 100) | fn inflight_count() {

FILE: pingora-limits/src/lib.rs
  function hash (line 30) | fn hash<T: Hash>(key: T, hasher: &RandomState) -> u64 {

FILE: pingora-limits/src/rate.rs
  type RateComponents (line 34) | pub struct RateComponents {
  type Rate (line 63) | pub struct Rate {
    method new (line 81) | pub fn new(interval: std::time::Duration) -> Self {
    method new_with_estimator_config (line 87) | pub fn new_with_estimator_config(
    method current (line 103) | fn current(&self, red_or_blue: bool) -> &Estimator {
    method previous (line 111) | fn previous(&self, red_or_blue: bool) -> &Estimator {
    method red_or_blue (line 119) | fn red_or_blue(&self) -> bool {
    method rate (line 126) | pub fn rate<T: Hash>(&self, key: &T) -> f64 {
    method observe (line 137) | pub fn observe<T: Hash>(&self, key: &T, events: isize) -> isize {
    method maybe_reset (line 143) | fn maybe_reset(&self) -> u64 {
    method rate_with (line 191) | pub fn rate_with<F, T, K>(&self, key: &K, mut rate_calc_fn: F) -> T
  constant HASHES (line 76) | const HASHES: usize = 4;
  constant SLOTS (line 77) | const SLOTS: usize = 1024;
  function test_observe_rate (line 232) | fn test_observe_rate() {
  function assert_eq_ish (line 262) | fn assert_eq_ish(left: f64, right: f64) {
  function test_observe_rate_custom_90_10 (line 267) | fn test_observe_rate_custom_90_10() {
  function test_observe_rate_custom_proportional (line 300) | fn test_observe_rate_custom_proportional() {

FILE: pingora-load-balancing/src/background.rs
  function run (line 27) | pub async fn run(
  method start_with_ready_notifier (line 81) | async fn start_with_ready_notifier(
  method start (line 89) | async fn start(&self, shutdown: pingora_core::server::ShutdownWatch) -> ...

FILE: pingora-load-balancing/src/discovery.rs
  type ServiceDiscovery (line 33) | pub trait ServiceDiscovery {
    method discover (line 37) | async fn discover(&self) -> Result<(BTreeSet<Backend>, HashMap<u64, bo...
    method discover (line 104) | async fn discover(&self) -> Result<(BTreeSet<Backend>, HashMap<u64, bo...
  type Static (line 44) | pub struct Static {
    method new (line 50) | pub fn new(backends: BTreeSet<Backend>) -> Box<Self> {
    method try_from_iter (line 57) | pub fn try_from_iter<A, T: IntoIterator<Item = A>>(iter: T) -> IoResul...
    method get (line 74) | pub fn get(&self) -> BTreeSet<Backend> {
    method set (line 83) | pub(crate) fn set(&self, backends: BTreeSet<Backend>) {
    method add (line 88) | pub(crate) fn add(&self, backend: Backend) {
    method remove (line 95) | pub(crate) fn remove(&self, backend: &Backend) {

FILE: pingora-load-balancing/src/health_check.rs
  type HealthObserve (line 33) | pub trait HealthObserve {
    method observe (line 35) | async fn observe(&self, target: &Backend, healthy: bool);
  type HealthObserveCallback (line 38) | pub type HealthObserveCallback = Box<dyn HealthObserve + Send + Sync>;
  type BackendSummary (line 41) | pub type BackendSummary = Box<dyn Fn(&Backend) -> String + Send + Sync>;
  type HealthCheck (line 45) | pub trait HealthCheck {
    method check (line 49) | async fn check(&self, target: &Backend) -> Result<()>;
    method health_status_change (line 52) | async fn health_status_change(&self, _target: &Backend, _healthy: bool...
    method backend_summary (line 55) | fn backend_summary(&self, target: &Backend) -> String {
    method health_threshold (line 63) | fn health_threshold(&self, success: bool) -> usize;
    method health_threshold (line 128) | fn health_threshold(&self, success: bool) -> usize {
    method check (line 136) | async fn check(&self, target: &Backend) -> Result<()> {
    method health_status_change (line 142) | async fn health_status_change(&self, target: &Backend, healthy: bool) {
    method health_threshold (line 275) | fn health_threshold(&self, success: bool) -> usize {
    method check (line 283) | async fn check(&self, target: &Backend) -> Result<()> {
    method health_status_change (line 331) | async fn health_status_change(&self, target: &Backend, healthy: bool) {
    method backend_summary (line 336) | fn backend_summary(&self, target: &Backend) -> String {
  type TcpHealthCheck (line 69) | pub struct TcpHealthCheck {
    method new (line 107) | pub fn new() -> Box<Self> {
    method new_tls (line 114) | pub fn new_tls(sni: &str) -> Box<Self> {
    method set_connector (line 121) | pub fn set_connector(&mut self, connector: TransportConnector) {
  method default (line 89) | fn default() -> Self {
  type Validator (line 149) | type Validator = Box<dyn Fn(&ResponseHeader) -> Result<()> + Send + Sync>;
  type HttpHealthCheck (line 154) | pub struct HttpHealthCheck<C = ()>
  function new (line 202) | pub fn new(host: &str, tls: bool) -> Self {
  function new_custom (line 236) | pub fn new_custom(host: &str, tls: bool, custom: HttpConnector<C>) -> Se...
  function set_connector (line 258) | pub fn set_connector(&mut self, connector: HttpConnector<C>) {
  function set_backend_summary (line 262) | pub fn set_backend_summary<F>(&mut self, callback: F)
  type HealthInner (line 346) | struct HealthInner {
  type Health (line 358) | pub(crate) struct Health(ArcSwap<HealthInner>);
    method ready (line 378) | pub fn ready(&self) -> bool {
    method enable (line 383) | pub fn enable(&self, enabled: bool) {
    method observe_health (line 394) | pub fn observe_health(&self, health: bool, flip_threshold: usize) -> b...
  method default (line 361) | fn default() -> Self {
  method clone (line 371) | fn clone(&self) -> Self {
  function test_tcp_check (line 432) | async fn test_tcp_check() {
  function test_tls_check (line 454) | async fn test_tls_check() {
  function test_https_check (line 467) | async fn test_https_check() {
  function test_http_custom_check (line 480) | async fn test_http_custom_check() {
  function test_health_observe (line 505) | async fn test_health_observe() {

FILE: pingora-load-balancing/src/lib.rs
  type Backend (line 56) | pub struct Backend {
    method new (line 79) | pub fn new(addr: &str) -> Result<Self> {
    method new_with_weight (line 85) | pub fn new_with_weight(addr: &str, weight: usize) -> Result<Self> {
    method hash_key (line 97) | pub(crate) fn hash_key(&self) -> u64 {
    type Target (line 105) | type Target = SocketAddr;
    method deref (line 107) | fn deref(&self) -> &Self::Target {
    method deref_mut (line 113) | fn deref_mut(&mut self) -> &mut Self::Target {
    type Iter (line 119) | type Iter = std::iter::Once<std::net::SocketAddr>;
    method to_socket_addrs (line 121) | fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
  type Backends (line 131) | pub struct Backends {
    method new (line 142) | pub fn new(discovery: Box<dyn ServiceDiscovery + Send + Sync + 'static...
    method set_health_check (line 152) | pub fn set_health_check(
    method do_update (line 162) | fn do_update<F>(
    method ready (line 211) | pub fn ready(&self, backend: &Backend) -> bool {
    method set_enable (line 226) | pub fn set_enable(&self, backend: &Backend, enabled: bool) {
    method get_backend (line 234) | pub fn get_backend(&self) -> Arc<BTreeSet<Backend>> {
    method update (line 242) | pub async fn update<F>(&self, callback: F) -> Result<()>
    method run_health_check (line 254) | pub async fn run_health_check(&self, parallel: bool) {
  type LoadBalancer (line 311) | pub struct LoadBalancer<S>
  function try_from_iter (line 341) | pub fn try_from_iter<A, T: IntoIterator<Item = A>>(iter: T) -> IoResult<...
  function from_backends_with_config (line 356) | pub fn from_backends_with_config(backends: Backends, config_opt: Option<...
  function from_backends (line 376) | pub fn from_backends(backends: Backends) -> Self {
  function update (line 384) | pub async fn update(&self) -> Result<()> {
  function select (line 408) | pub fn select(&self, key: &[u8], max_iterations: usize) -> Option<Backen...
  function select_with (line 419) | pub fn select_with<F>(&self, key: &[u8], max_iterations: usize, accept: ...
  function set_health_check (line 434) | pub fn set_health_check(
  function backends (line 442) | pub fn backends(&self) -> &Backends {
  function test_static_backends (line 455) | async fn test_static_backends() {
  function test_backends (line 467) | async fn test_backends() {
  function test_backends_with_ext (line 508) | async fn test_backends_with_ext() {
  function test_discovery_readiness (line 534) | async fn test_discovery_readiness() {
  function test_parallel_health_check (line 577) | async fn test_parallel_health_check() {
  type MockDiscovery (line 608) | struct MockDiscovery {
  method discover (line 613) | async fn discover(&self) -> Result<(BTreeSet<Backend>, HashMap<u64, bool...
  function test_consistency (line 626) | async fn test_consistency() {

FILE: pingora-load-balancing/src/selection/algorithms.rs
  method new (line 27) | fn new() -> Self {
  method next (line 30) | fn next(&self, key: &[u8]) -> u64 {
  type RoundRobin (line 38) | pub struct RoundRobin(AtomicUsize);
  method new (line 41) | fn new() -> Self {
  method next (line 44) | fn next(&self, _key: &[u8]) -> u64 {
  type Random (line 50) | pub struct Random;
  method new (line 53) | fn new() -> Self {
  method next (line 56) | fn next(&self, _key: &[u8]) -> u64 {

FILE: pingora-load-balancing/src/selection/consistent.rs
  type KetamaHashing (line 23) | pub struct KetamaHashing {
  type KetamaConfig (line 30) | pub struct KetamaConfig {
  type Iter (line 35) | type Iter = OwnedNodeIterator;
  type Config (line 37) | type Config = KetamaConfig;
  method build_with_config (line 39) | fn build_with_config(backends: &BTreeSet<Backend>, config: &Self::Config...
  method build (line 76) | fn build(backends: &BTreeSet<Backend>) -> Self {
  method iter (line 80) | fn iter(self: &Arc<Self>, key: &[u8]) -> Self::Iter {
  type OwnedNodeIterator (line 89) | pub struct OwnedNodeIterator {
  method next (line 95) | fn next(&mut self) -> Option<&Backend> {
  function test_ketama (line 108) | fn test_ketama() {

FILE: pingora-load-balancing/src/selection/mod.rs
  type BackendSelection (line 27) | pub trait BackendSelection: Sized {
    method build_with_config (line 36) | fn build_with_config(backends: &BTreeSet<Backend>, _config: &Self::Con...
    method build (line 41) | fn build(backends: &BTreeSet<Backend>) -> Self;
    method iter (line 47) | fn iter(self: &Arc<Self>, key: &[u8]) -> Self::Iter
  type BackendIter (line 55) | pub trait BackendIter {
    method next (line 57) | fn next(&mut self) -> Option<&Backend>;
    method next (line 148) | fn next(&mut self) -> Option<&Backend> {
  type SelectionAlgorithm (line 63) | pub trait SelectionAlgorithm {
    method new (line 65) | fn new() -> Self;
    method next (line 68) | fn next(&self, key: &[u8]) -> u64;
  type FNVHash (line 73) | pub type FNVHash = Weighted<fnv::FnvHasher>;
  type FVNHash (line 77) | pub type FVNHash = Weighted<fnv::FnvHasher>;
  type Random (line 79) | pub type Random = Weighted<algorithms::Random>;
  type RoundRobin (line 81) | pub type RoundRobin = Weighted<algorithms::RoundRobin>;
  type Consistent (line 83) | pub type Consistent = consistent::KetamaHashing;
  type UniqueIterator (line 89) | pub struct UniqueIterator<I>
  function new (line 104) | pub fn new(iter: I, max_iterations: usize) -> Self {
  function get_next (line 113) | pub fn get_next(&mut self) -> Option<Backend> {
  type TestIter (line 135) | struct TestIter {
    method new (line 140) | fn new(input: &[&Backend]) -> Self {
  function unique_iter_max_iterations_is_correct (line 156) | fn unique_iter_max_iterations_is_correct() {
  function unique_iter_duplicate_items_are_filtered (line 174) | fn unique_iter_duplicate_items_are_filtered() {

FILE: pingora-load-balancing/src/selection/weighted.rs
  type Weighted (line 25) | pub struct Weighted<H = FnvHasher> {
  type Iter (line 33) | type Iter = WeightedIterator<H>;
  type Config (line 35) | type Config = ();
  method build (line 37) | fn build(backends: &BTreeSet<Backend>) -> Self {
  method iter (line 56) | fn iter(self: &Arc<Self>, key: &[u8]) -> Self::Iter {
  type WeightedIterator (line 64) | pub struct WeightedIterator<H> {
  function new (line 73) | fn new(input: &[u8], backend: Arc<Weighted<H>>) -> Self {
  method next (line 83) | fn next(&mut self) -> Option<&Backend> {
  function test_fnv (line 112) | fn test_fnv() {
  function test_round_robin (line 154) | fn test_round_robin() {
  function test_random (line 198) | fn test_random() {

FILE: pingora-lru/benches/bench_linked_list.rs
  function main (line 17) | fn main() {

FILE: pingora-lru/benches/bench_lru.rs
  constant WEIGHTS (line 22) | const WEIGHTS: &[usize] = &[
  constant ITERATIONS (line 29) | const ITERATIONS: usize = 5_000_000;
  constant THREADS (line 30) | const THREADS: usize = 8;
  function main (line 32) | fn main() {

FILE: pingora-lru/src/lib.rs
  type Lru (line 31) | pub struct Lru<T, const N: usize> {
  function with_capacity (line 45) | pub fn with_capacity(weight_limit: usize, capacity: usize) -> Self {
  function with_capacity_and_watermark (line 55) | pub fn with_capacity_and_watermark(
  function admit (line 79) | pub fn admit(&self, key: u64, data: T, weight: usize) -> usize {
  function increment_weight (line 105) | pub fn increment_weight(&self, key: u64, delta: usize, max_weight: Optio...
  function promote (line 125) | pub fn promote(&self, key: u64) -> bool {
  function promote_top_n (line 136) | pub fn promote_top_n(&self, key: u64, top: usize) -> bool {
  function evict_shard (line 147) | pub fn evict_shard(&self, shard: u64) -> Option<(T, usize)> {
  function evict_to_limit (line 163) | pub fn evict_to_limit(&self) -> Vec<(T, usize)> {
  function remove (line 194) | pub fn remove(&self, key: u64) -> Option<(T, usize)> {
  function insert_tail (line 206) | pub fn insert_tail(&self, key: u64, data: T, weight: usize) -> bool {
  function peek (line 220) | pub fn peek(&self, key: u64) -> bool {
  function peek_weight (line 225) | pub fn peek_weight(&self, key: u64) -> Option<usize> {
  function weight (line 230) | pub fn weight(&self) -> usize {
  function evicted_weight (line 235) | pub fn evicted_weight(&self) -> usize {
  function evicted_len (line 240) | pub fn evicted_len(&self) -> usize {
  function len (line 246) | pub fn len(&self) -> usize {
  function iter_for_each (line 251) | pub fn iter_for_each<F>(&self, shard: usize, f: F)
  function shards (line 260) | pub const fn shards(&self) -> usize {
  function shard_len (line 265) | pub fn shard_len(&self, shard: usize) -> usize {
  function shard_weight (line 270) | pub fn shard_weight(&self, shard: usize) -> usize {
  function get_shard (line 276) | fn get_shard(key: u64, n_shards: usize) -> usize {
  type LruNode (line 280) | struct LruNode<T> {
  type LruUnit (line 286) | struct LruUnit<T> {
  function with_capacity (line 293) | fn with_capacity(capacity: usize) -> Self {
  function peek (line 302) | pub fn peek(&self, key: u64) -> Option<&T> {
  function peek_weight (line 307) | pub fn peek_weight(&self, key: u64) -> Option<usize> {
  function admit (line 312) | pub fn admit(&mut self, key: u64, data: T, weight: usize) -> usize {
  function increment_weight (line 335) | pub fn increment_weight(
  function access (line 351) | pub fn access(&mut self, key: u64) -> bool {
  function need_promote (line 364) | pub fn need_promote(&self, key: u64, limit: usize) -> bool {
  function evict (line 369) | pub fn evict(&mut self) -> Option<(T, usize)> {
  function remove (line 379) | pub fn remove(&mut self, key: u64) -> Option<(T, usize)> {
  function insert_tail (line 388) | pub fn insert_tail(&mut self, key: u64, data: T, weight: usize) -> bool {
  function len (line 403) | pub fn len(&self) -> usize {
  function used_weight (line 409) | pub fn used_weight(&self) -> usize {
  function iter (line 413) | pub fn iter(&self) -> LruUnitIter<'_, T> {
  function adjust_weight (line 423) | fn adjust_weight(node: &mut LruNode<T>, used_weight: &mut usize, weight:...
  type LruUnitIter (line 434) | struct LruUnitIter<'a, T> {
  type Item (line 440) | type Item = (&'a T, usize);
  method next (line 442) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 450) | fn size_hint(&self) -> (usize, Option<usize>) {
  method next_back (line 456) | fn next_back(&mut self) -> Option<Self::Item> {
  function assert_lru (line 469) | fn assert_lru<T: Copy + PartialEq + std::fmt::Debug, const N: usize>(
  function test_admit (line 480) | fn test_admit() {
  function test_promote (line 504) | fn test_promote() {
  function test_evict (line 547) | fn test_evict() {
  function test_increment_weight (line 595) | fn test_increment_weight() {
  function test_remove (line 613) | fn test_remove() {
  function test_peek (line 644) | fn test_peek() {
  function test_insert_tail (line 659) | fn test_insert_tail() {
  function test_watermark_eviction (line 682) | fn test_watermark_eviction() {
  function assert_lru (line 705) | fn assert_lru<T: Copy + PartialEq + std::fmt::Debug>(lru: &LruUnit<T>, v...
  function test_admit (line 711) | fn test_admit() {
  function test_access (line 732) | fn test_access() {
  function test_evict (line 756) | fn test_evict() {
  function test_increment_weight (line 788) | fn test_increment_weight() {
  function test_remove (line 810) | fn test_remove() {
  function test_insert_tail (line 848) | fn test_insert_tail() {

FILE: pingora-lru/src/linked_list.rs
  type Index (line 28) | type Index = usize;
  constant NULL (line 29) | const NULL: Index = usize::MAX;
  constant HEAD (line 30) | const HEAD: Index = 0;
  constant TAIL (line 31) | const TAIL: Index = 1;
  constant OFFSET (line 32) | const OFFSET: usize = 2;
  type Node (line 35) | struct Node {
  type Nodes (line 43) | struct Nodes {
    method with_capacity (line 52) | fn with_capacity(capacity: usize) -> Self {
    method new_node (line 68) | fn new_node(&mut self, data: u64) -> Index {
    method len (line 91) | fn len(&self) -> usize {
    method head (line 95) | fn head(&self) -> &Node {
    method tail (line 99) | fn tail(&self) -> &Node {
    type Output (line 105) | type Output = Node;
    method index (line 107) | fn index(&self, index: usize) -> &Self::Output {
    method index_mut (line 117) | fn index_mut(&mut self, index: usize) -> &mut Self::Output {
  type LinkedList (line 127) | pub struct LinkedList {
    method with_capacity (line 135) | pub fn with_capacity(capacity: usize) -> Self {
    method new_node (line 144) | fn new_node(&mut self, data: u64) -> Index {
    method len (line 157) | pub fn len(&self) -> usize {
    method valid_index (line 162) | fn valid_index(&self, index: Index) -> bool {
    method node (line 168) | fn node(&self, index: Index) -> Option<&Node> {
    method peek (line 177) | pub fn peek(&self, index: Index) -> Option<u64> {
    method peek_unchecked (line 182) | fn peek_unchecked(&self, index: Index) -> &u64 {
    method exist_near_head (line 188) | pub fn exist_near_head(&self, value: u64, search_limit: usize) -> bool {
    method insert_after (line 203) | fn insert_after(&mut self, node_index: Index, at: Index) {
    method push_head (line 216) | pub fn push_head(&mut self, data: u64) -> Index {
    method push_tail (line 223) | pub fn push_tail(&mut self, data: u64) -> Index {
    method lift (line 231) | fn lift(&mut self, index: Index) -> u64 {
    method remove (line 252) | pub fn remove(&mut self, index: Index) -> u64 {
    method pop_tail (line 258) | pub fn pop_tail(&mut self) -> Option<u64> {
    method promote (line 268) | pub fn promote(&mut self, index: Index) {
    method next (line 276) | fn next(&self, index: Index) -> Index {
    method prev (line 280) | fn prev(&self, index: Index) -> Index {
    method head (line 285) | pub fn head(&self) -> Option<Index> {
    method tail (line 295) | pub fn tail(&self) -> Option<Index> {
    method iter (line 305) | pub fn iter(&self) -> LinkedListIter<'_> {
  type LinkedListIter (line 316) | pub struct LinkedListIter<'a> {
  type Item (line 324) | type Item = &'a u64;
  method next (line 326) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 337) | fn size_hint(&self) -> (usize, Option<usize>) {
  method next_back (line 343) | fn next_back(&mut self) -> Option<Self::Item> {
  function assert_list (line 360) | fn assert_list(list: &LinkedList, values: &[u64]) {
  function assert_list_reverse (line 365) | fn assert_list_reverse(list: &LinkedList, values: &[u64]) {
  function test_insert (line 371) | fn test_insert() {
  function test_pop (line 395) | fn test_pop() {
  function test_promote (line 408) | fn test_promote() {
  function test_exist_near_head (line 426) | fn test_exist_near_head() {

FILE: pingora-memory-cache/src/lib.rs
  type CacheStatus (line 28) | pub enum CacheStatus {
    method as_str (line 44) | pub fn as_str(&self) -> &str {
    method is_hit (line 55) | pub fn is_hit(&self) -> bool {
    method stale (line 63) | pub fn stale(&self) -> Option<Duration> {
  type Node (line 72) | struct Node<T: Clone> {
  function new (line 78) | fn new(value: T, ttl: Option<Duration>) -> Self {
  function will_expire_at (line 86) | fn will_expire_at(&self, time: &Instant) -> bool {
  function is_expired (line 90) | fn is_expired(&self) -> bool {
  function stale_duration (line 94) | fn stale_duration(&self, time: &Instant) -> Option<Duration> {
  type MemoryCache (line 105) | pub struct MemoryCache<K: Hash, T: Clone> {
  function new (line 113) | pub fn new(size: usize) -> Self {
  function get (line 122) | pub fn get<Q>(&self, key: &Q) -> (Option<T>, CacheStatus)
  function get_stale (line 144) | pub fn get_stale<Q>(&self, key: &Q) -> (Option<T>, CacheStatus)
  function put (line 166) | pub fn put<Q>(&self, key: &Q, value: T, ttl: Option<Duration>)
  function remove (line 183) | pub fn remove<Q>(&self, key: &Q)
  function force_put (line 192) | pub(crate) fn force_put(&self, key: &K, value: T, ttl: Option<Duration>) {
  function multi_get (line 205) | pub fn multi_get<'a, I, Q>(&self, keys: I) -> Vec<(Option<T>, CacheStatus)>
  function multi_get_with_miss (line 219) | pub fn multi_get_with_miss<'a, I, Q>(
  function test_get (line 249) | fn test_get() {
  function test_put_get (line 257) | fn test_put_get() {
  function test_put_get_remove (line 269) | fn test_put_get_remove() {
  function test_get_expired (line 294) | fn test_get_expired() {
  function test_get_stale (line 307) | fn test_get_stale() {
  function test_eviction (line 321) | fn test_eviction() {
  function test_multi_get (line 338) | fn test_multi_get() {
  function test_get_with_mismatched_key (line 362) | fn test_get_with_mismatched_key() {
  function test_put_get_with_mismatched_key (line 370) | fn test_put_get_with_mismatched_key() {

FILE: pingora-memory-cache/src/read_through.rs
  type CacheLock (line 31) | struct CacheLock {
    method new_arc (line 37) | pub fn new_arc() -> Arc<Self> {
    method too_old (line 44) | pub fn too_old(&self, age: Option<&Duration>) -> bool {
  type Lookup (line 75) | pub trait Lookup<K, T, S> {
    method lookup (line 77) | async fn lookup(
  type MultiLookup (line 89) | pub trait MultiLookup<K, T, S> {
    method multi_lookup (line 91) | async fn multi_lookup(
  constant LOOKUP_ERR_MSG (line 100) | const LOOKUP_ERR_MSG: &str = "RTCache: lookup error";
  type RTCache (line 110) | pub struct RTCache<K, T, CB, S>
  function new (line 130) | pub fn new(size: usize, lock_age: Option<Duration>, lock_timeout: Option...
  function get (line 150) | pub async fn get(
  function get_stale (line 289) | pub async fn get_stale(
  function get_stale_while_update (line 322) | pub async fn get_stale_while_update(
  function multi_get (line 355) | pub async fn multi_get<'a, I>(
  type ExtraOpt (line 417) | struct ExtraOpt {
  type TestCB (line 424) | struct TestCB();
    method lookup (line 428) | async fn lookup(
    method multi_lookup (line 449) | async fn multi_lookup(
  function test_basic_get (line 467) | async fn test_basic_get() {
  function test_basic_get_error (line 484) | async fn test_basic_get_error() {
  function test_concurrent_get (line 498) | async fn test_concurrent_get() {
  function test_concurrent_get_error (line 533) | async fn test_concurrent_get_error() {
  function test_concurrent_get_different_value (line 567) | async fn test_concurrent_get_different_value() {
  function test_get_lock_age (line 600) | async fn test_get_lock_age() {
  function test_get_lock_timeout (line 644) | async fn test_get_lock_timeout() {
  function test_multi_get (line 686) | async fn test_multi_get() {
  function test_inconsistent_miss_results (line 728) | async fn test_inconsistent_miss_results() {
  function test_get_stale (line 744) | async fn test_get_stale() {
  function test_get_stale_while_update (line 774) | async fn test_get_stale_while_update() {

FILE: pingora-openssl/src/ext.rs
  function cvt (line 30) | fn cvt(r: c_long) -> Result<c_long, ErrorStack> {
  function X509_VERIFY_PARAM_add1_host (line 39) | pub fn X509_VERIFY_PARAM_add1_host(
  function SSL_use_certificate (line 45) | pub fn SSL_use_certificate(ssl: *mut SSL, cert: *mut X509) -> c_int;
  function SSL_use_PrivateKey (line 46) | pub fn SSL_use_PrivateKey(ssl: *mut SSL, key: *mut EVP_PKEY) -> c_int;
  function SSL_set_cert_cb (line 48) | pub fn SSL_set_cert_cb(
  function add_host (line 60) | pub fn add_host(verify_param: &mut X509VerifyParamRef, host: &str) -> Re...
  function ssl_set_verify_cert_store (line 77) | pub fn ssl_set_verify_cert_store(
  function ssl_use_certificate (line 95) | pub fn ssl_use_certificate(ssl: &mut SslRef, cert: &X509Ref) -> Result<(...
  function ssl_use_private_key (line 105) | pub fn ssl_use_private_key<T>(ssl: &mut SslRef, key: &PKeyRef<T>) -> Res...
  function ssl_add_chain_cert (line 118) | pub fn ssl_add_chain_cert(ssl: &mut SslRef, cert: &X509Ref) -> Result<()...
  function ssl_set_renegotiate_mode_freely (line 134) | pub fn ssl_set_renegotiate_mode_freely(_ssl: &mut SslRef) {}
  function ssl_set_groups_list (line 139) | pub fn ssl_set_groups_list(ssl: &mut SslRef, groups: &str) -> Result<(),...
  function ssl_use_second_key_share (line 158) | pub fn ssl_use_second_key_share(_ssl: &mut SslRef, _enabled: bool) {}
  function clear_error_stack (line 165) | pub fn clear_error_stack() {
  function ssl_from_acceptor (line 172) | pub fn ssl_from_acceptor(acceptor: &SslAcceptor) -> Result<Ssl, ErrorSta...
  function suspend_when_need_ssl_cert (line 181) | pub fn suspend_when_need_ssl_cert(ssl: &mut SslRef) {
  function unblock_ssl_cert (line 190) | pub fn unblock_ssl_cert(ssl: &mut SslRef) {
  function raw_cert_block (line 197) | extern "C" fn raw_cert_block(_ssl: *mut openssl_sys::SSL, _arg: *mut c_v...
  function is_suspended_for_cert (line 202) | pub fn is_suspended_for_cert(error: &openssl::ssl::Error) -> bool {
  function ssl_mut (line 210) | pub unsafe fn ssl_mut(ssl: &SslRef) -> &mut SslRef {
  function test_ssl_set_groups_list (line 220) | fn test_ssl_set_groups_list() {

FILE: pingora-pool/src/connection.rs
  type GroupKey (line 29) | type GroupKey = u64;
  type ID (line 31) | type ID = i32;
  type ID (line 33) | type ID = usize;
  type ConnectionMeta (line 37) | pub struct ConnectionMeta {
    method new (line 46) | pub fn new(key: GroupKey, id: ID) -> Self {
  type PoolConnection (line 51) | struct PoolConnection<S> {
  function new (line 57) | pub fn new(notify_use: oneshot::Sender<bool>, connection: S) -> Self {
  function release (line 64) | pub fn release(self) -> S {
  type PoolNode (line 75) | pub struct PoolNode<T> {
  constant HOT_QUEUE_SIZE (line 85) | const HOT_QUEUE_SIZE: usize = 16;
  function new (line 89) | pub fn new() -> Self {
  function get_any (line 98) | pub fn get_any(&self) -> Option<(ID, T)> {
  function insert (line 119) | pub fn insert(&self, id: ID, conn: T) {
  function is_empty (line 140) | pub fn is_empty(&self) -> bool {
  function remove (line 150) | pub fn remove(&self, id: ID) -> Option<T> {
  type ConnectionPool (line 183) | pub struct ConnectionPool<S> {
  function new (line 193) | pub fn new(size: usize) -> Self {
  function get_pool_node (line 201) | fn get_pool_node(&self, key: GroupKey) -> Arc<PoolNode<PoolConnection<S>...
  function try_remove_empty_node (line 246) | fn try_remove_empty_node(&self, key: GroupKey) {
  function pop_evicted (line 256) | fn pop_evicted(&self, meta: &ConnectionMeta) {
  function pop_closed (line 280) | pub fn pop_closed(&self, meta: &ConnectionMeta) {
  function get (line 287) | pub fn get(&self, key: &GroupKey) -> Option<S> {
  function put (line 319) | pub fn put(
  function idle_poll (line 341) | pub async fn idle_poll<Stream>(
  function idle_timeout (line 386) | pub async fn idle_timeout(
  function read_with_timeout (line 417) | async fn read_with_timeout<S>(
  function test_lookup (line 446) | async fn test_lookup() {
  function test_pop (line 470) | async fn test_pop() {
  function test_eviction (line 492) | async fn test_eviction() {
  function test_read_close (line 518) | async fn test_read_close() {
  function test_read_timeout (line 546) | async fn test_read_timeout() {
  function test_evict_poll (line 576) | async fn test_evict_poll() {
  function test_pool_node_is_empty (line 606) | fn test_pool_node_is_empty() {
  function test_pool_node_is_empty_overflow_to_connections (line 628) | fn test_pool_node_is_empty_overflow_to_connections() {
  function test_empty_node_removed_after_pop_closed (line 644) | async fn test_empty_node_removed_after_pop_closed() {
  function test_empty_node_removed_after_get (line 663) | async fn test_empty_node_removed_after_get() {
  function test_empty_node_removed_when_get_finds_empty_node (line 685) | async fn test_empty_node_removed_when_get_finds_empty_node() {
  function test_node_not_removed_when_connections_remain (line 708) | async fn test_node_not_removed_when_connections_remain() {
  function test_empty_node_cleanup_only_affects_target_key (line 731) | async fn test_empty_node_cleanup_only_affects_target_key() {
  function test_empty_node_cleaned_after_lru_eviction (line 758) | async fn test_empty_node_cleaned_after_lru_eviction() {
  function test_node_reusable_after_cleanup (line 779) | async fn test_node_reusable_after_cleanup() {

FILE: pingora-pool/src/lru.rs
  type Node (line 24) | pub struct Node<T> {
  function new (line 30) | pub fn new(meta: T) -> Self {
  function notify_close (line 37) | pub fn notify_close(&self) {
  type Lru (line 42) | pub struct Lru<K, T>
  function new (line 57) | pub fn new(size: usize) -> Self {
  function put (line 66) | pub fn put(&self, key: K, value: Node<T>) -> Option<T> {
  function add (line 90) | pub fn add(&self, key: K, meta: T) -> (Arc<Notify>, Option<T>) {
  function pop (line 97) | pub fn pop(&self, key: &K) -> Option<Node<T>> {
  function drain (line 107) | pub fn drain(&self) {
  function test_evict_close (line 131) | async fn test_evict_close() {
  function test_evict_close_with_pop (line 145) | async fn test_evict_close_with_pop() {
  function test_drain (line 162) | async fn test_drain() {

FILE: pingora-proxy/examples/backoff_retry.rs
  type RetryCtx (line 29) | struct RetryCtx {
  type BackoffRetryProxy (line 33) | struct BackoffRetryProxy;
  type CTX (line 37) | type CTX = RetryCtx;
  method new_ctx (line 38) | fn new_ctx(&self) -> Self::CTX {
  method fail_to_connect (line 42) | fn fail_to_connect(
  method upstream_peer (line 55) | async fn upstream_peer(
  function main (line 77) | fn main() {

FILE: pingora-proxy/examples/connection_filter.rs
  type MyProxy (line 27) | pub struct MyProxy;
  type CTX (line 31) | type CTX = ();
  method new_ctx (line 33) | fn new_ctx(&self) -> Self::CTX {}
  method upstream_peer (line 35) | async fn upstream_peer(
  type BlockAllFilter (line 48) | struct BlockAllFilter;
  method should_accept (line 52) | async fn should_accept(&self, addr: &std::net::SocketAddr) -> bool {
  function main (line 60) | fn main() {

FILE: pingora-proxy/examples/ctx.rs
  type MyProxy (line 28) | pub struct MyProxy {
  type MyCtx (line 33) | pub struct MyCtx {
  function check_beta_user (line 37) | fn check_beta_user(req: &pingora_http::RequestHeader) -> bool {
  type CTX (line 44) | type CTX = MyCtx;
  method new_ctx (line 45) | fn new_ctx(&self) -> Self::CTX {
  method request_filter (line 49) | async fn request_filter(&self, session: &mut Session, ctx: &mut Self::CT...
  method upstream_peer (line 54) | async fn upstream_peer(
  function main (line 80) | fn main() {

FILE: pingora-proxy/examples/gateway.rs
  function check_login (line 27) | fn check_login(req: &pingora_http::RequestHeader) -> bool {
  type MyGateway (line 32) | pub struct MyGateway {
  type CTX (line 38) | type CTX = ();
  method new_ctx (line 39) | fn new_ctx(&self) -> Self::CTX {}
  method request_filter (line 41) | async fn request_filter(&self, session: &mut Session, _ctx: &mut Self::C...
  method upstream_peer (line 54) | async fn upstream_peer(
  method response_filter (line 71) | async fn response_filter(
  method logging (line 90) | async fn logging(
  function main (line 115) | fn main() {

FILE: pingora-proxy/examples/grpc_web_module.rs
  type GrpcWebBridgeProxy (line 31) | pub struct GrpcWebBridgeProxy;
  type CTX (line 35) | type CTX = ();
  method new_ctx (line 36) | fn new_ctx(&self) -> Self::CTX {}
  method init_downstream_modules (line 38) | fn init_downstream_modules(&self, modules: &mut HttpModules) {
  method early_request_filter (line 43) | async fn early_request_filter(
  method upstream_peer (line 58) | async fn upstream_peer(
  function main (line 75) | fn main() {

FILE: pingora-proxy/examples/load_balancer.rs
  type LB (line 27) | pub struct LB(Arc<LoadBalancer<RoundRobin>>);
  type CTX (line 31) | type CTX = ();
  method new_ctx (line 32) | fn new_ctx(&self) -> Self::CTX {}
  method upstream_peer (line 34) | async fn upstream_peer(&self, _session: &mut Session, _ctx: &mut ()) -> ...
  method upstream_request_filter (line 46) | async fn upstream_request_filter(
  function main (line 60) | fn main() {

FILE: pingora-proxy/examples/modify_response.rs
  constant HOST (line 27) | const HOST: &str = "ip.jsontest.com";
  type Resp (line 30) | pub struct Resp {
  type Json2Yaml (line 34) | pub struct Json2Yaml {
  type MyCtx (line 38) | pub struct MyCtx {
  type CTX (line 44) | type CTX = MyCtx;
  method new_ctx (line 45) | fn new_ctx(&self) -> Self::CTX {
  method upstream_peer (line 49) | async fn upstream_peer(
  method upstream_request_filter (line 58) | async fn upstream_request_filter(
  method response_filter (line 70) | async fn response_filter(
  method response_body_filter (line 87) | fn response_body_filter(
  function main (line 116) | fn main() {

FILE: pingora-proxy/examples/multi_lb.rs
  type Router (line 26) | struct Router {
  type CTX (line 33) | type CTX = ();
  method new_ctx (line 34) | fn new_ctx(&self) {}
  method upstream_peer (line 36) | async fn upstream_peer(&self, session: &mut Session, _ctx: &mut ()) -> R...
  function build_cluster_service (line 56) | fn build_cluster_service<S>(upstreams: &[&str]) -> GenBackgroundService<...
  function main (line 71) | fn main() {

FILE: pingora-proxy/examples/rate_limiter.rs
  function main (line 12) | fn main() {
  type LB (line 33) | pub struct LB(Arc<LoadBalancer<RoundRobin>>);
    method get_request_appid (line 36) | pub fn get_request_appid(&self, session: &mut Session) -> Option<Strin...
  type CTX (line 60) | type CTX = ();
  method new_ctx (line 62) | fn new_ctx(&self) {}
  method upstream_peer (line 64) | async fn upstream_peer(
  method upstream_request_filter (line 75) | async fn upstream_request_filter(
  method request_filter (line 90) | async fn request_filter(&self, session: &mut Session, _ctx: &mut Self::C...

FILE: pingora-proxy/examples/use_module.rs
  type MyAclCtx (line 35) | struct MyAclCtx {
  method request_header_filter (line 42) | async fn request_header_filter(&mut self, req: &mut RequestHeader) -> Re...
  method as_any (line 55) | fn as_any(&self) -> &dyn Any {
  method as_any_mut (line 58) | fn as_any_mut(&mut self) -> &mut dyn Any {
  type MyAcl (line 64) | pub struct MyAcl {
  method init (line 70) | fn init(&self) -> Module {
  type MyProxy (line 80) | pub struct MyProxy;
  type CTX (line 84) | type CTX = ();
  method new_ctx (line 85) | fn new_ctx(&self) -> Self::CTX {}
  method init_downstream_modules (line 88) | fn init_downstream_modules(&self, modules: &mut HttpModules) {
  method upstream_peer (line 95) | async fn upstream_peer(
  function main (line 113) | fn main() {

FILE: pingora-proxy/examples/virtual_l4.rs
  type StaticVirtualSocket (line 26) | struct StaticVirtualSocket {
    method new (line 32) | fn new() -> Self {
  method poll_read (line 42) | fn poll_read(
  method poll_write (line 63) | fn poll_write(
  method poll_flush (line 72) | fn poll_flush(
  method poll_shutdown (line 79) | fn poll_shutdown(
  method set_socket_option (line 88) | fn set_socket_option(
  type VirtualConnector (line 97) | struct VirtualConnector;
  method connect (line 101) | async fn connect(&self, _addr: &L4SocketAddr) -> pingora_error::Result<S...
  type VirtualProxy (line 108) | struct VirtualProxy {
    method new (line 113) | fn new() -> Self {
  type CTX (line 122) | type CTX = ();
  method new_ctx (line 124) | fn new_ctx(&self) -> Self::CTX {}
  method upstream_peer (line 128) | async fn upstream_peer(
  function main (line 151) | fn main() {

FILE: pingora-proxy/src/lib.rs
  constant TASK_BUFFER_SIZE (line 79) | const TASK_BUFFER_SIZE: usize = 4;
  type ProcessCustomSession (line 100) | pub type ProcessCustomSession<SV, C> = Arc<
  type HttpProxy (line 111) | pub struct HttpProxy<SV, C = ()>
  function new (line 147) | pub fn new(inner: SV, conf: Arc<ServerConf>) -> Self {
  function new_custom (line 166) | fn new_custom(
  function handle_init_modules (line 201) | pub fn handle_init_modules(&mut self)
  function handle_new_request (line 209) | async fn handle_new_request(
  function proxy_to_upstream (line 279) | async fn proxy_to_upstream(
  function upstream_filter (line 365) | async fn upstream_filter(
  function finish (line 399) | async fn finish(
  function cleanup_sub_req (line 433) | fn cleanup_sub_req(&self, session: &mut Session) {
  type Session (line 447) | pub struct Session {
    method new (line 474) | fn new(
    method new_h1 (line 499) | pub fn new_h1(stream: Stream) -> Self {
    method new_h1_with_modules (line 512) | pub fn new_h1_with_modules(stream: Stream, downstream_modules: &HttpMo...
    method as_downstream_mut (line 520) | pub fn as_downstream_mut(&mut self) -> &mut HttpSession {
    method as_downstream (line 524) | pub fn as_downstream(&self) -> &HttpSession {
    method respond_error (line 529) | pub async fn respond_error(&mut self, error: u16) -> Result<()> {
    method respond_error_with_body (line 534) | pub async fn respond_error_with_body(&mut self, error: u16, body: Byte...
    method write_response_header (line 544) | pub async fn write_response_header(
    method write_response_header_ref (line 556) | pub async fn write_response_header_ref(
    method write_response_body (line 569) | pub async fn write_response_body(
    method write_response_tasks (line 587) | pub async fn write_response_tasks(&mut self, mut tasks: Vec<HttpTask>)...
    method mark_upstream_headers_mutated_for_cache (line 644) | pub fn mark_upstream_headers_mutated_for_cache(&mut self) {
    method upstream_headers_mutated_for_cache (line 649) | pub fn upstream_headers_mutated_for_cache(&self) -> bool {
    method upstream_body_bytes_received (line 654) | pub fn upstream_body_bytes_received(&self) -> usize {
    method set_upstream_body_bytes_received (line 659) | pub(crate) fn set_upstream_body_bytes_received(&mut self, n: usize) {
    method upstream_write_pending_time (line 664) | pub fn upstream_write_pending_time(&self) -> Duration {
    method set_upstream_write_pending_time (line 669) | pub(crate) fn set_upstream_write_pending_time(&mut self, d: Duration) {
    method is_process_shutting_down (line 674) | pub fn is_process_shutting_down(&self) -> bool {
    method downstream_custom_message (line 678) | pub fn downstream_custom_message(
    method as_ref (line 698) | fn as_ref(&self) -> &HttpSession {
    method as_mut (line 704) | fn as_mut(&mut self) -> &mut HttpSession {
  type Target (line 712) | type Target = HttpSession;
  method deref (line 714) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 720) | fn deref_mut(&mut self) -> &mut Self::Target {
  function process_request (line 741) | async fn process_request(
  function handle_error (line 948) | async fn handle_error(
  type Subrequest (line 998) | pub trait Subrequest {
    method process_subrequest (line 999) | async fn process_subrequest(
    method process_subrequest (line 1013) | async fn process_subrequest(
  type SubrequestSpawner (line 1042) | pub struct SubrequestSpawner {
    method new (line 1071) | pub fn new(app: Arc<dyn Subrequest + Send + Sync>) -> SubrequestSpawner {
    method spawn_background_subrequest (line 1077) | pub fn spawn_background_subrequest(
    method create_subrequest (line 1104) | pub fn create_subrequest(
  type PreparedSubrequest (line 1047) | pub struct PreparedSubrequest {
    method run (line 1054) | pub async fn run(self) {
    method session (line 1060) | pub fn session(&self) -> &HttpSession {
    method session_mut (line 1064) | pub fn session_mut(&mut self) -> &mut HttpSession {
  method process_new_http (line 1136) | async fn process_new_http(
  method http_cleanup (line 1162) | async fn http_cleanup(&self) {
  method server_options (line 1168) | fn server_options(&self) -> Option<&HttpServerOptions> {
  method h2_options (line 1172) | fn h2_options(&self) -> Option<H2Options> {
  method process_custom_session (line 1175) | async fn process_custom_session(
  function http_proxy (line 1225) | pub fn http_proxy<SV>(conf: &Arc<ServerConf>, inner: SV) -> HttpProxy<SV>
  function http_proxy_service (line 1237) | pub fn http_proxy_service<SV>(conf: &Arc<ServerConf>, inner: SV) -> Serv...
  function http_proxy_service_with_name (line 1247) | pub fn http_proxy_service_with_name<SV>(
  function http_proxy_service_with_name_custom (line 1263) | pub fn http_proxy_service_with_name_custom<SV, C>(
  type ProxyServiceBuilder (line 1286) | pub struct ProxyServiceBuilder<SV, C>
  function new (line 1314) | pub fn new(conf: &Arc<ServerConf>, inner: SV) -> Self {
  function name (line 1333) | pub fn name(mut self, name: impl AsRef<str>) -> Self {
  function custom (line 1346) | pub fn custom<C2: custom::Connector>(
  function server_options (line 1371) | pub fn server_options(mut self, options: HttpServerOptions) -> Self {
  function build (line 1382) | pub fn build(self) -> Service<HttpProxy<SV, C>> {

FILE: pingora-proxy/src/proxy_cache.rs
  function proxy_cache (line 33) | pub(crate) async fn proxy_cache(
  function proxy_cache_hit (line 264) | pub(crate) async fn proxy_cache_hit(
  function downstream_response_conditional_filter (line 505) | pub(crate) fn downstream_response_conditional_filter(
  function cache_http_task (line 543) | pub(crate) async fn cache_http_task(
  function revalidate_or_stale (line 725) | pub(crate) async fn revalidate_or_stale(
  function handle_stale_if_error (line 860) | pub(crate) async fn handle_stale_if_error(
  function handle_lock_status (line 902) | fn handle_lock_status(
  function cache_hit_header (line 954) | fn cache_hit_header(cache: &HttpCache) -> Box<ResponseHeader> {
  function parse_number (line 996) | fn parse_number(input: &[u8]) -> Option<usize> {
  function parse_range_header (line 1000) | fn parse_range_header(
  function test_parse_range (line 1124) | fn test_parse_range() {
  function test_parse_range_header_multi (line 1167) | fn test_parse_range_header_multi() {
  type MultiRangeInfo (line 1275) | pub struct MultiRangeInfo {
    method new (line 1284) | pub fn new(ranges: Vec<Range<usize>>) -> Self {
    method set_content_type (line 1293) | pub fn set_content_type(&mut self, content_type: String) {
    method set_total_length (line 1296) | pub fn set_total_length(&mut self, total_length: usize) {
    method generate_boundary (line 1303) | fn generate_boundary() -> String {
    method calculate_multipart_length (line 1308) | pub fn calculate_multipart_length(&self) -> usize {
  type RangeType (line 1337) | pub enum RangeType {
    method new_single (line 1347) | fn new_single(start: usize, end: usize) -> Self {
    method new_multi (line 1351) | pub fn new_multi(ranges: Vec<Range<usize>>) -> Self {
    method get_multirange_info (line 1355) | fn get_multirange_info(&self) -> Option<&MultiRangeInfo> {
    method update_multirange_info (line 1362) | fn update_multirange_info(&mut self, content_length: usize, content_ty...
  function range_header_filter (line 1371) | pub fn range_header_filter(
  function test_range_filter_single (line 1505) | fn test_range_filter_single() {
  function test_range_filter_multipart (line 1594) | fn test_range_filter_multipart() {
  function test_if_range (line 1669) | fn test_if_range() {
  type RangeBodyFilter (line 1773) | pub struct RangeBodyFilter {
    method new (line 1787) | pub fn new() -> Self {
    method new_range (line 1796) | pub fn new_range(range: RangeType) -> Self {
    method is_multipart_range (line 1804) | pub fn is_multipart_range(&self) -> bool {
    method should_cache_seek_again (line 1810) | pub fn should_cache_seek_again(&self) -> bool {
    method next_cache_multipart_range (line 1820) | pub fn next_cache_multipart_range(&mut self) -> Range<usize> {
    method set_current_cursor (line 1839) | pub fn set_current_cursor(&mut self, current: usize) {
    method set (line 1843) | pub fn set(&mut self, range: RangeType) {
    method finalize (line 1849) | pub fn finalize(&self, boundary: &String) -> Option<Bytes> {
    method filter_body (line 1857) | pub fn filter_body(&mut self, data: Option<Bytes>) -> Option<Bytes> {
    method filter_range_data (line 1877) | fn filter_range_data(
    method build_multipart_header (line 1899) | fn build_multipart_header(
    method current_chunk_includes_range_start (line 1917) | fn current_chunk_includes_range_start(
    method current_chunk_includes_range_end (line 1927) | fn current_chunk_includes_range_end(
    method filter_multi_range_body (line 1936) | fn filter_multi_range_body(
  method default (line 1781) | fn default() -> Self {
  function test_range_body_filter_single (line 1994) | fn test_range_body_filter_single() {
  function test_range_body_filter_multipart (line 2017) | fn test_range_body_filter_multipart() {
  type ServeFromCache (line 2215) | pub(crate) enum ServeFromCache {
    method new (line 2239) | pub fn new() -> Self {
    method is_on (line 2243) | pub fn is_on(&self) -> bool {
    method is_miss (line 2247) | pub fn is_miss(&self) -> bool {
    method is_miss_header (line 2257) | pub fn is_miss_header(&self) -> bool {
    method is_miss_body (line 2263) | pub fn is_miss_body(&self) -> bool {
    method should_discard_upstream (line 2267) | pub fn should_discard_upstream(&self) -> bool {
    method should_send_to_downstream (line 2271) | pub fn should_send_to_downstream(&self) -> bool {
    method enable (line 2275) | pub fn enable(&mut self) {
    method enable_miss (line 2279) | pub fn enable_miss(&mut self) {
    method enable_header_only (line 2285) | pub fn enable_header_only(&mut self) {
    method next_http_task (line 2300) | pub async fn next_http_task(
    method maybe_seek_miss_handler (line 2382) | fn maybe_seek_miss_handler(
    method maybe_seek_hit_handler (line 2423) | fn maybe_seek_hit_handler(

FILE: pingora-proxy/src/proxy_common.rs
  type DownstreamStateMachine (line 3) | pub(crate) enum DownstreamStateMachine {
    method new (line 14) | pub fn new(finished: bool) -> Self {
    method can_poll (line 23) | pub fn can_poll(&self) -> bool {
    method is_reading (line 27) | pub fn is_reading(&self) -> bool {
    method is_done (line 31) | pub fn is_done(&self) -> bool {
    method is_errored (line 35) | pub fn is_errored(&self) -> bool {
    method maybe_finished (line 40) | pub fn maybe_finished(&mut self, set: bool) {
    method reset (line 48) | pub fn reset(&mut self) {
    method to_errored (line 52) | pub fn to_errored(&mut self) {
  type ResponseStateMachine (line 59) | pub(crate) struct ResponseStateMachine {
    method new (line 65) | pub fn new() -> Self {
    method is_done (line 72) | pub fn is_done(&self) -> bool {
    method upstream_done (line 76) | pub fn upstream_done(&self) -> bool {
    method cached_done (line 80) | pub fn cached_done(&self) -> bool {
    method enable_cached_response (line 84) | pub fn enable_cached_response(&mut self) {
    method maybe_set_upstream_done (line 88) | pub fn maybe_set_upstream_done(&mut self, done: bool) {
    method maybe_set_cache_done (line 94) | pub fn maybe_set_cache_done(&mut self, done: bool) {

FILE: pingora-proxy/src/proxy_custom.rs
  function proxy_to_custom_upstream (line 35) | pub(crate) async fn proxy_to_custom_upstream(
  function custom_proxy_down_to_up (line 72) | async fn custom_proxy_down_to_up(
  function custom_bidirection_down_to_up (line 262) | async fn custom_bidirection_down_to_up(
  function custom_response_filter (line 525) | async fn custom_response_filter(
  function send_body_to_custom (line 665) | async fn send_body_to_custom(
  function custom_pipe_up_to_down_response (line 721) | async fn custom_pipe_up_to_down_response<S: CustomSession>(
  type CustomMessageForwarder (line 830) | struct CustomMessageForwarder<'a> {
  function proxy (line 841) | async fn proxy(mut self) -> Result<()> {

FILE: pingora-proxy/src/proxy_h1.rs
  function proxy_1to1 (line 28) | pub(crate) async fn proxy_1to1(
  function proxy_to_h1_upstream (line 135) | pub(crate) async fn proxy_to_h1_upstream(
  function proxy_handle_upstream (line 185) | async fn proxy_handle_upstream(
  function proxy_handle_downstream (line 272) | async fn proxy_handle_downstream(
  function h1_response_filter (line 603) | async fn h1_response_filter(
  function send_body_to_pipe (line 759) | async fn send_body_to_pipe(
  function send_body_to1 (line 814) | pub(crate) async fn send_body_to1(

FILE: pingora-proxy/src/proxy_h2.rs
  function update_h2_scheme_authority (line 27) | fn update_h2_scheme_authority(
  function proxy_down_to_up (line 78) | pub(crate) async fn proxy_down_to_up(
  function proxy_to_h2_upstream (line 227) | pub(crate) async fn proxy_to_h2_upstream(
  function bidirection_down_to_up (line 266) | async fn bidirection_down_to_up(
  function h2_response_filter (line 549) | async fn h2_response_filter(
  function send_body_to2 (line 710) | async fn send_body_to2(
  function pipe_up_to_down_response (line 757) | pub(crate) async fn pipe_up_to_down_response(
  function test_update_authority (line 881) | fn test_update_authority() {

FILE: pingora-proxy/src/proxy_purge.rs
  type PurgeStatus (line 20) | pub enum PurgeStatus {
  function purge_response (line 34) | fn purge_response(purge_status: &PurgeStatus) -> Cow<'static, ResponseHe...
  function gen_purge_response (line 44) | fn gen_purge_response(code: u16) -> ResponseHeader {
  function proxy_purge (line 66) | pub(crate) async fn proxy_purge(

FILE: pingora-proxy/src/proxy_trait.rs
  type ProxyHttp (line 31) | pub trait ProxyHttp {
    method new_ctx (line 36) | fn new_ctx(&self) -> Self::CTX;
    method upstream_peer (line 42) | async fn upstream_peer(
    method init_downstream_modules (line 54) | fn init_downstream_modules(&self, modules: &mut HttpModules) {
    method request_filter (line 68) | async fn request_filter(&self, _session: &mut Session, _ctx: &mut Self...
    method early_request_filter (line 84) | async fn early_request_filter(&self, _session: &mut Session, _ctx: &mu...
    method allow_spawning_subrequest (line 99) | fn allow_spawning_subrequest(&self, _session: &Session, _ctx: &Self::C...
    method request_body_filter (line 114) | async fn request_body_filter(
    method request_cache_filter (line 133) | fn request_cache_filter(&self, _session: &mut Session, _ctx: &mut Self...
    method cache_key_callback (line 156) | fn cache_key_callback(&self, _session: &Session, _ctx: &mut Self::CTX)...
    method cache_miss (line 161) | fn cache_miss(&self, session: &mut Session, _ctx: &mut Self::CTX) {
    method cache_hit_filter (line 174) | async fn cache_hit_filter(
    method proxy_upstream_filter (line 198) | async fn proxy_upstream_filter(
    method response_cache_filter (line 210) | fn response_cache_filter(
    method cache_vary_filter (line 222) | fn cache_vary_filter(
    method cache_not_modified_filter (line 241) | fn cache_not_modified_filter(
    method range_header_filter (line 265) | fn range_header_filter(
    method upstream_request_filter (line 283) | async fn upstream_request_filter(
    method upstream_response_filter (line 302) | async fn upstream_response_filter(
    method response_filter (line 318) | async fn response_filter(
    method custom_forwarding (line 332) | async fn custom_forwarding(
    method downstream_custom_message_proxy_filter (line 347) | async fn downstream_custom_message_proxy_filter(
    method upstream_custom_message_proxy_filter (line 362) | async fn upstream_custom_message_proxy_filter(
    method upstream_response_body_filter (line 379) | fn upstream_response_body_filter(
    method upstream_response_trailer_filter (line 390) | fn upstream_response_trailer_filter(
    method response_body_filter (line 400) | fn response_body_filter(
    method response_trailer_filter (line 418) | async fn response_trailer_filter(
    method logging (line 435) | async fn logging(&self, _session: &mut Session, _e: Option<&Error>, _c...
    method suppress_error_log (line 442) | fn suppress_error_log(&self, _session: &Session, _ctx: &Self::CTX, _er...
    method error_while_proxy (line 448) | fn error_while_proxy(
    method fail_to_connect (line 471) | fn fail_to_connect(
    method fail_to_proxy (line 489) | async fn fail_to_proxy(
    method should_serve_stale (line 537) | fn should_serve_stale(
    method connected_to_upstream (line 553) | async fn connected_to_upstream(
    method request_summary (line 572) | fn request_summary(&self, session: &Session, _ctx: &Self::CTX) -> Stri...
    method is_purge (line 580) | fn is_purge(&self, _session: &Session, _ctx: &Self::CTX) -> bool {
    method purge_response_filter (line 590) | fn purge_response_filter(
  type FailToProxy (line 602) | pub struct FailToProxy {

FILE: pingora-proxy/src/subrequest/mod.rs
  type LockCtx (line 25) | struct LockCtx {
  type InputBodyReader (line 32) | pub(crate) struct InputBodyReader(std::vec::IntoIter<Bytes>);
    method read_body (line 35) | pub fn read_body(&mut self) -> Option<Bytes> {
  type UserCtx (line 41) | pub type UserCtx = Box<dyn Any + Sync + Send>;
  type BodyMode (line 44) | pub enum BodyMode {
  type CtxBuilder (line 53) | pub struct CtxBuilder {
    method new (line 60) | pub fn new() -> Self {
    method cache_write_lock (line 68) | pub fn cache_write_lock(
    method user_ctx (line 82) | pub fn user_ctx(mut self, user_ctx: UserCtx) -> Self {
    method body_mode (line 87) | pub fn body_mode(mut self, body_mode: BodyMode) -> Self {
    method build (line 92) | pub fn build(self) -> Ctx {
  type Ctx (line 102) | pub struct Ctx {
    method builder (line 111) | pub fn builder() -> CtxBuilder {
    method user_ctx (line 116) | pub fn user_ctx(&self) -> Option<&UserCtx> {
    method user_ctx_mut (line 121) | pub fn user_ctx_mut(&mut self) -> Option<&mut UserCtx> {
    method release_write_lock (line 127) | pub fn release_write_lock(&mut self) {
    method take_write_lock (line 138) | pub fn take_write_lock(&mut self) -> Option<WritePermit> {
    method body_mode (line 144) | pub fn body_mode(&self) -> BodyMode {
  function create_session (line 151) | pub(crate) fn create_session(parsed_session: &HttpSession) -> (HttpSessi...
  function test_dummy_request (line 157) | async fn test_dummy_request() {

FILE: pingora-proxy/src/subrequest/pipe.rs
  type InputBodyType (line 38) | pub enum InputBodyType {
  type PipeSubrequestState (line 47) | pub struct PipeSubrequestState {
    method new (line 53) | fn new() -> PipeSubrequestState {
  type PipeSubrequestError (line 58) | pub struct PipeSubrequestError {
    method new (line 66) | pub fn new(
  function map_pipe_err (line 79) | fn map_pipe_err<T, E: Into<Box<Error>>>(
  type SavedBody (line 88) | pub struct SavedBody {
    method new (line 97) | pub fn new(max_length: usize) -> Self {
    method save_body_bytes (line 107) | pub fn save_body_bytes(&mut self, body_bytes: Bytes) -> bool {
    method is_body_complete (line 118) | pub fn is_body_complete(&self) -> bool {
    method set_body_complete (line 122) | pub fn set_body_complete(&mut self) {
  type InputBody (line 128) | pub enum InputBody {
    method into_reader (line 135) | pub(crate) fn into_reader(self) -> InputBodyReader {
    method is_body_empty (line 142) | pub fn is_body_empty(&self) -> bool {
    method from (line 151) | fn from(body: SavedBody) -> Self {
  function pipe_subrequest (line 160) | pub async fn pipe_subrequest<F>(
  function send_body_to_pipe (line 343) | async fn send_body_to_pipe(
  function do_send_body_to_pipe (line 363) | fn do_send_body_to_pipe(

FILE: pingora-proxy/tests/test_basic.rs
  function is_specified_port (line 29) | fn is_specified_port(port: u16) -> bool {
  function test_origin_alive (line 34) | async fn test_origin_alive() {
  function test_simple_proxy (line 45) | async fn test_simple_proxy() {
  function test_h2_to_h1 (line 76) | async fn test_h2_to_h1() {
  function test_h2_to_h2 (line 119) | async fn test_h2_to_h2() {
  function test_h2c_to_h2c (line 161) | async fn test_h2c_to_h2c() {
  function test_h1_on_h2c_port (line 183) | async fn test_h1_on_h2c_port() {
  function test_h2_to_h2_host_override (line 206) | async fn test_h2_to_h2_host_override() {
  function test_h2_to_h2_upload (line 230) | async fn test_h2_to_h2_upload() {
  function test_h2_to_h1_upload (line 255) | async fn test_h2_to_h1_upload() {
  function test_h2_head (line 279) | async fn test_h2_head() {
  function test_simple_proxy_uds (line 303) | async fn test_simple_proxy_uds() {
  function test_simple_proxy_uds_peer (line 333) | async fn test_simple_proxy_uds_peer() {
  function test_dropped_conn_get (line 367) | async fn test_dropped_conn_get() {
  function test_dropped_conn_post_empty_body (line 396) | async fn test_dropped_conn_post_empty_body() {
  function test_dropped_conn_post_body (line 424) | async fn test_dropped_conn_post_body() {
  function test_dropped_conn_post_body_over (line 453) | async fn test_dropped_conn_post_body_over() {
  function test_dropped_conn (line 483) | async fn test_dropped_conn() {
  function test_tls_no_verify (line 495) | async fn test_tls_no_verify() {
  function test_tls_verify_sni_not_host (line 509) | async fn test_tls_verify_sni_not_host() {
  function test_tls_none_verify_host (line 527) | async fn test_tls_none_verify_host() {
  function test_tls_verify_sni_host (line 544) | async fn test_tls_verify_sni_host() {
  function test_tls_underscore_sub_sni_verify_host (line 562) | async fn test_tls_underscore_sub_sni_verify_host() {
  function test_tls_underscore_non_sub_sni_verify_host (line 580) | async fn test_tls_underscore_non_sub_sni_verify_host() {
  function test_tls_alt_verify_host (line 600) | async fn test_tls_alt_verify_host() {
  function test_tls_underscore_sub_alt_verify_host (line 619) | async fn test_tls_underscore_sub_alt_verify_host() {
  function test_tls_underscore_non_sub_alt_verify_host (line 638) | async fn test_tls_underscore_non_sub_alt_verify_host() {
  function test_upstream_compression (line 656) | async fn test_upstream_compression() {
  function test_downstream_compression (line 687) | async fn test_downstream_compression() {
  function test_connect_close (line 720) | async fn test_connect_close() {
  function test_connect_proxying_disallowed_h1 (line 750) | async fn test_connect_proxying_disallowed_h1() {
  function test_connect_proxying_disallowed_h2 (line 765) | async fn test_connect_proxying_disallowed_h2() {
  function test_connect_proxying_allowed_h1 (line 788) | async fn test_connect_proxying_allowed_h1() {
  function test_mtls_no_client_cert (line 822) | async fn test_mtls_no_client_cert() {
  function test_mtls_no_intermediate_cert (line 842) | async fn test_mtls_no_intermediate_cert() {
  function test_mtls (line 863) | async fn test_mtls() {
  function assert_reuse (line 882) | async fn assert_reuse(req: reqwest::RequestBuilder) {
  function test_mtls_diff_cert_no_reuse (line 891) | async fn test_mtls_diff_cert_no_reuse() {
  function test_tls_diff_verify_no_reuse (line 926) | async fn test_tls_diff_verify_no_reuse() {
  function test_tls_diff_verify_host_no_reuse (line 953) | async fn test_tls_diff_verify_host_no_reuse() {
  function test_tls_diff_alt_cnt_no_reuse (line 982) | async fn test_tls_diff_alt_cnt_no_reuse() {
  function test_tls_psk (line 1013) | async fn test_tls_psk() {
  function test_tls_psk_invalid (line 1032) | async fn test_tls_psk_invalid() {
  function test_error_before_headers_sent (line 1048) | async fn test_error_before_headers_sent() {
  function test_error_after_headers_sent_rst_received (line 1077) | async fn test_error_after_headers_sent_rst_received() {
  function test_103 (line 1103) | async fn test_103() {
  function test_103_die (line 1114) | async fn test_103_die() {

FILE: pingora-proxy/tests/test_upstream.rs
  function test_ip_binding (line 31) | async fn test_ip_binding() {
  function test_duplex (line 42) | async fn test_duplex() {
  function test_connection_die (line 62) | async fn test_connection_die() {
  function test_upload_connection_die (line 74) | async fn test_upload_connection_die() {
  function test_upload (line 104) | async fn test_upload() {
  function test_close_on_response_before_downstream_finish (line 120) | async fn test_close_on_response_before_downstream_finish() {
  function test_ws_server_ends_conn (line 139) | async fn test_ws_server_ends_conn() {
  function parse_response_header (line 191) | fn parse_response_header(buf: &[u8]) -> ResponseHeader {
  function read_response_header (line 209) | async fn read_response_header(stream: &mut tokio::net::TcpStream) -> (Re...
  function read_response_body (line 234) | async fn read_response_body(
  function read_response (line 250) | async fn read_response(
  function test_upgrade_smoke (line 260) | async fn test_upgrade_smoke() {
  function test_upgrade_body (line 286) | async fn test_upgrade_body() {
  function test_upgrade_body_after_101 (line 315) | async fn test_upgrade_body_after_101() {
  function test_download_timeout (line 364) | async fn test_download_timeout() {
  function test_download_timeout_min_rate (line 390) | async fn test_download_timeout_min_rate() {
  function test_basic_caching (line 423) | async fn test_basic_caching() {
  function test_purge (line 456) | async fn test_purge() {
  function test_cache_miss_convert (line 510) | async fn test_cache_miss_convert() {
  function test_cache_http10 (line 543) | async fn test_cache_http10() {
  function test_cache_downstream_compression (line 598) | async fn test_cache_downstream_compression() {
  function test_cache_downstream_decompression (line 636) | async fn test_cache_downstream_decompression() {
  function test_network_error_mid_response (line 697) | async fn test_network_error_mid_response() {
  function test_cache_upstream_revalidation (line 735) | async fn test_cache_upstream_revalidation() {
  function test_cache_upstream_revalidation_appends_headers (line 772) | async fn test_cache_upstream_revalidation_appends_headers() {
  function test_force_miss (line 825) | async fn test_force_miss() {
  function test_force_miss_stale (line 862) | async fn test_force_miss_stale() {
  function test_force_fresh (line 904) | async fn test_force_fresh() {
  function test_cache_downstream_revalidation_etag (line 946) | async fn test_cache_downstream_revalidation_etag() {
  function test_cache_downstream_revalidation_last_modified (line 1015) | async fn test_cache_downstream_revalidation_last_modified() {
  function test_cache_downstream_head (line 1084) | async fn test_cache_downstream_head() {
  function test_purge_reject (line 1123) | async fn test_purge_reject() {
  function test_cache_websocket_101 (line 1142) | async fn test_cache_websocket_101() {
  function test_1xx_caching (line 1191) | async fn test_1xx_caching() {
  function test_bypassed_became_cacheable (line 1285) | async fn test_bypassed_became_cacheable() {
  function test_bypassed_304 (line 1329) | async fn test_bypassed_304() {
  function test_bypassed_uncacheable_304 (line 1386) | async fn test_bypassed_uncacheable_304() {
  function test_bypassed_head (line 1434) | async fn test_bypassed_head() {
  function test_eviction (line 1477) | async fn test_eviction() {
  function test_cache_lock_miss_hit (line 1561) | async fn test_cache_lock_miss_hit() {
  function test_cache_lock_expired (line 1657) | async fn test_cache_lock_expired() {
  function test_cache_lock_network_error (line 1723) | async fn test_cache_lock_network_error() {
  function test_cache_lock_uncacheable (line 1783) | async fn test_cache_lock_uncacheable() {
  function test_cache_lock_timeout (line 1834) | async fn test_cache_lock_timeout() {
  function test_cache_lock_wait_timeout (line 1895) | async fn test_cache_lock_wait_timeout() {
  function test_cache_serve_stale_network_error (line 1935) | async fn test_cache_serve_stale_network_error() {
  function test_cache_serve_stale_network_error_mid_response (line 1966) | async fn test_cache_serve_stale_network_error_mid_response() {
  function test_cache_serve_stale_on_500 (line 2000) | async fn test_cache_serve_stale_on_500() {
  function test_stale_while_revalidate_many_readers (line 2031) | async fn test_stale_while_revalidate_many_readers() {
  function test_stale_while_revalidate_single_request (line 2089) | async fn test_stale_while_revalidate_single_request() {
  function test_cache_streaming_partial_body (line 2135) | async fn test_cache_streaming_partial_body() {
  function test_cache_streaming_multiple_writers (line 2212) | async fn test_cache_streaming_multiple_writers() {
  function test_range_request (line 2249) | async fn test_range_request() {
  function test_multipart_range_request (line 2323) | async fn test_multipart_range_request() {
  function test_single_then_mutltipart_range_request (line 2517) | async fn test_single_then_mutltipart_range_request() {
  function test_caching_when_downstream_bails (line 2594) | async fn test_caching_when_downstream_bails() {
  function test_caching_when_downstream_bails_uncacheable (line 2634) | async fn test_caching_when_downstream_bails_uncacheable() {
  function test_caching_when_downstream_bails_header (line 2668) | async fn test_caching_when_downstream_bails_header() {
  function test_caching_when_downstream_bails_header_uncacheable (line 2700) | async fn test_caching_when_downstream_bails_header_uncacheable() {
  function send_vary_req_with_headers_with_dups (line 2735) | async fn send_vary_req_with_headers_with_dups(
  function send_vary_req_with_headers (line 2763) | async fn send_vary_req_with_headers(
  function send_vary_req (line 2771) | async fn send_vary_req(url: &str, vary_field: &str, value: &str) -> reqw...
  function test_vary_caching (line 2776) | async fn test_vary_caching() {
  function test_vary_caching_ignored_vary_header (line 2816) | async fn test_vary_caching_ignored_vary_header() {
  function test_vary_some_ignored (line 2852) | async fn test_vary_some_ignored() {
  function test_vary_dup_header_some_ignored (line 2966) | async fn test_vary_dup_header_some_ignored() {
  function test_vary_purge (line 3029) | async fn test_vary_purge() {
  function send_max_file_size_req (line 3073) | async fn send_max_file_size_req(
  function test_cache_max_file_size (line 3089) | async fn test_cache_max_file_size() {
  function test_cache_max_file_size_chunked (line 3134) | async fn test_cache_max_file_size_chunked() {
  function test_cache_max_file_size_range (line 3191) | async fn test_cache_max_file_size_range() {
  function test_cache_h2_premature_end (line 3230) | async fn test_cache_h2_premature_end() {
  function test_cache_bypass_downstream_range (line 3260) | async fn test_cache_bypass_downstream_range() {
  function test_downstream_head_miss_conn_close_h1 (line 3297) | async fn test_downstream_head_miss_conn_close_h1() {
  function test_downstream_head_miss_conn_close_h2 (line 3324) | async fn test_downstream_head_miss_conn_close_h2() {

FILE: pingora-proxy/tests/utils/cert.rs
  type PrivateKeyType (line 30) | pub type PrivateKeyType = PKey<Private>;
  type CertType (line 31) | pub type CertType = X509;
  type PrivateKeyType (line 37) | pub type PrivateKeyType = Vec<u8>;
  type CertType (line 38) | pub type CertType = Vec<u8>;
  type PrivateKeyType (line 44) | pub type PrivateKeyType = Vec<u8>;
  type CertType (line 45) | pub type CertType = Vec<u8>;
  function load_cert (line 63) | fn load_cert(path: &str) -> X509 {
  function load_key (line 69) | fn load_key(path: &str) -> PKey<Private> {
  function load_cert (line 76) | fn load_cert(path: &str) -> Vec<u8> {
  function load_key (line 82) | fn load_key(path: &str) -> Vec<u8> {
  function load_cert (line 88) | fn load_cert(path: &str) -> Vec<u8> {
  function load_key (line 94) | fn load_key(path: &str) -> Vec<u8> {

FILE: pingora-proxy/tests/utils/mock_origin.rs
  function init (line 22) | fn init() -> bool {

FILE: pingora-proxy/tests/utils/mod.rs
  function conf_dir (line 32) | pub fn conf_dir() -> String {

FILE: pingora-proxy/tests/utils/server_utils.rs
  type ExampleProxyHttps (line 52) | pub struct ExampleProxyHttps {}
  constant TEST_PSK_IDENTITY (line 54) | pub const TEST_PSK_IDENTITY: &str = "test-psk-identity";
  constant TEST_PSK_SECRET (line 55) | pub const TEST_PSK_SECRET: &str = "i2Wx8jrYVi5Vt7HSL/fsk003+PnmfcFuwWMsU...
  type CTX (line 59) | pub struct CTX {
  function connected_to_upstream_common (line 66) | fn connected_to_upstream_common(
  function response_filter_common (line 83) | fn response_filter_common(
  type CTX (line 122) | type CTX = CTX;
  method new_ctx (line 123) | fn new_ctx(&self) -> Self::CTX {
  method upstream_peer (line 127) | async fn upstream_peer(
  method response_filter (line 203) | async fn response_filter(
  method upstream_request_filter (line 215) | async fn upstream_request_filter(
  method connected_to_upstream (line 228) | async fn connected_to_upstream(
  type ExampleProxyHttp (line 242) | pub struct ExampleProxyHttp {}
  type CTX (line 246) | type CTX = CTX;
  method new_ctx (line 247) | fn new_ctx(&self) -> Self::CTX {
  method early_request_filter (line 251) | async fn early_request_filter(
  method request_filter (line 271) | async fn request_filter(&self, session: &mut Session, _ctx: &mut Self::C...
  method response_filter (line 310) | async fn response_filter(
  method upstream_peer (line 319) | async fn upstream_peer(
  method connected_to_upstream (line 352) | async fn connected_to_upstream(
  constant CACHE_DEFAULT (line 367) | const CACHE_DEFAULT: CacheMetaDefaults =
  type CacheCTX (line 378) | pub struct CacheCTX {
  type ExampleProxyCache (line 382) | pub struct ExampleProxyCache {}
  type CTX (line 386) | type CTX = CacheCTX;
  method new_ctx (line 387) | fn new_ctx(&self) -> Self::CTX {
  method early_request_filter (line 393) | async fn early_request_filter(
  method upstream_peer (line 425) | async fn upstream_peer(
  method request_cache_filter (line 450) | fn request_cache_filter(&self, session: &mut Session, _ctx: &mut Self::C...
  method cache_key_callback (line 498) | fn cache_key_callback(&self, session: &Session, _ctx: &mut Self::CTX) ->...
  method cache_hit_filter (line 521) | async fn cache_hit_filter(
  method cache_vary_filter (line 548) | fn cache_vary_filter(
  method upstream_request_filter (line 588) | async fn upstream_request_filter(
  method response_cache_filter (line 604) | fn response_cache_filter(
  method upstream_response_filter (line 635) | async fn upstream_response_filter(
  method response_filter (line 655) | async fn response_filter(
  method fail_to_proxy (line 697) | async fn fail_to_proxy(
  method should_serve_stale (line 747) | fn should_serve_stale(
  method is_purge (line 757) | fn is_purge(&self, session: &Session, _ctx: &Self::CTX) -> bool {
  function test_main (line 762) | fn test_main() {
  type Server (line 844) | pub struct Server {
    method start (line 849) | pub fn start() -> Self {
  type PskTlsServer (line 860) | pub struct PskTlsServer {
    method start (line 866) | pub fn start() -> Self {
    method run_server (line 876) | async fn run_server() {
  function init (line 925) | pub fn init() {

FILE: pingora-proxy/tests/utils/websocket/ws_echo.rs
  constant WS_ECHO_ORIGIN_PORT (line 26) | pub const WS_ECHO_ORIGIN_PORT: u16 = 9283;
  function init (line 28) | fn init() -> bool {
  function server (line 45) | async fn server(addr: &str) -> Result<(), Error> {
  function handle_connection (line 53) | async fn handle_connection(stream: TcpStream) {

FILE: pingora-proxy/tests/utils/websocket/ws_echo_raw.rs
  constant WS_ECHO_RAW_ORIGIN_PORT (line 32) | pub const WS_ECHO_RAW_ORIGIN_PORT: u16 = 9284;
  function init (line 34) | fn init() -> bool {
  function server (line 51) | async fn server(addr: &str) -> Result<(), Error> {
  function read_request_header (line 59) | async fn read_request_header(stream: &mut TcpStream) -> Result<(RequestH...
  function read_body_until_close (line 110) | async fn read_body_until_close(
  function write_body_until_close (line 121) | async fn write_body_until_close(
  function handle_connection (line 129) | async fn handle_connection(mut stream: TcpStream) -> Result<()> {

FILE: pingora-runtime/benches/hello.rs
  function hello_server (line 32) | async fn hello_server(port: usize) -> Result<(), Box<dyn Error + Send>> {
  function main (line 97) | fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {

FILE: pingora-runtime/src/lib.rs
  type Runtime (line 40) | pub enum Runtime {
    method new_steal (line 47) | pub fn new_steal(threads: usize, name: &str) -> Self {
    method new_no_steal (line 59) | pub fn new_no_steal(threads: usize, name: &str) -> Self {
    method get_handle (line 68) | pub fn get_handle(&self) -> &Handle {
    method shutdown_timeout (line 77) | pub fn shutdown_timeout(self, timeout: Duration) {
  function current_handle (line 92) | pub fn current_handle() -> Handle {
  type Control (line 105) | type Control = (Sender<Duration>, JoinHandle<()>);
  type Pools (line 106) | type Pools = Arc<OnceCell<Box<[Handle]>>>;
  type NoStealRuntime (line 109) | pub struct NoStealRuntime {
    method new (line 120) | pub fn new(threads: usize, name: &str) -> Self {
    method init_pools (line 130) | fn init_pools(&self) -> (Box<[Handle]>, Vec<Control>) {
    method get_runtime (line 155) | pub fn get_runtime(&self) -> &Handle {
    method threads (line 163) | pub fn threads(&self) -> usize {
    method get_pools (line 167) | fn get_pools(&self) -> &[Handle] {
    method get_runtime_at (line 187) | pub fn get_runtime_at(&self, index: usize) -> &Handle {
    method shutdown_timeout (line 194) | pub fn shutdown_timeout(mut self, timeout: Duration) {
  function test_steal_runtime (line 210) | fn test_steal_runtime() {
  function test_no_steal_runtime (line 231) | fn test_no_steal_runtime() {
  function test_no_steal_shutdown (line 250) | fn test_no_steal_shutdown() {

FILE: pingora-rustls/src/lib.rs
  function load_file (line 46) | fn load_file<P>(path: P) -> Result<BufReader<File>>
  function load_pem_file (line 56) | fn load_pem_file<P>(path: P) -> Result<Vec<Item>>
  function load_ca_file_into_store (line 72) | pub fn load_ca_file_into_store<P>(path: P, cert_store: &mut RootCertStor...
  function load_platform_certs_incl_env_into_store (line 94) | pub fn load_platform_certs_incl_env_into_store(ca_certs: &mut RootCertSt...
  function load_certs_and_key_files (line 110) | pub fn load_certs_and_key_files<'a>(
  function load_pem_file_ca (line 148) | pub fn load_pem_file_ca(path: &String) -> Result<Vec<u8>> {
  function load_pem_file_private_key (line 165) | pub fn load_pem_file_private_key(path: &String) -> Result<Vec<u8>> {
  function hash_certificate (line 175) | pub fn hash_certificate(cert: &CertificateDer) -> Vec<u8> {

FILE: pingora-s2n/src/lib.rs
  function load_certs_and_key_files (line 29) | pub fn load_certs_and_key_files(cert_file: &str, key_file: &str) -> Resu...
  function load_pem_file (line 35) | pub fn load_pem_file(file: &str) -> Result<Vec<u8>> {
  function hash_certificate (line 46) | pub fn hash_certificate(cert: &[u8]) -> Vec<u8> {
  type IgnoreVerifyHostnameCallback (line 53) | pub struct IgnoreVerifyHostnameCallback {}
    method new (line 56) | pub fn new() -> Self {
  method default (line 62) | fn default() -> Self {
  method verify_host_name (line 68) | fn verify_host_name(&self, _host_name: &str) -> bool {

FILE: pingora-timeout/benches/benchmark.rs
  constant LOOP_SIZE (line 20) | const LOOP_SIZE: u32 = 100000;
  function bench_timeout (line 22) | async fn bench_timeout() -> u32 {
  function bench_tokio_timeout (line 32) | async fn bench_tokio_timeout() -> u32 {
  function bench_fast_timeout (line 42) | async fn bench_fast_timeout() -> u32 {
  function bench_tokio_timer (line 52) | fn bench_tokio_timer() {
  function bench_multi_thread_tokio_timer (line 75) | async fn bench_multi_thread_tokio_timer(threads: usize) {
  function bench_multi_thread_timer (line 90) | async fn bench_multi_thread_timer(threads: usize, tm: Arc<TimerManager>) {
  function bench_timer (line 106) | fn bench_timer(tm: &TimerManager) {
  function main (line 130) | async fn main() {

FILE: pingora-timeout/src/fast_timeout.rs
  function check_clock_thread (line 38) | fn check_clock_thread(tm: &Arc<TimerManager>) {
  type FastTimeout (line 50) | pub struct FastTimeout(Duration);
  method timeout (line 53) | fn timeout(&self) -> Pin<Box<dyn Future<Output = ()> + Send + Sync>> {
  method create (line 57) | fn create(d: Duration) -> Self {
  function fast_timeout (line 63) | pub fn fast_timeout<T>(duration: Duration, future: T) -> Timeout<T, Fast...
  function fast_sleep (line 72) | pub async fn fast_sleep(duration: Duration) {
  function pause_for_fork (line 83) | pub fn pause_for_fork() {
  function unpause (line 90) | pub fn unpause() {
  function test_timeout (line 99) | async fn test_timeout() {
  function test_instantly_return (line 106) | async fn test_instantly_return() {
  function test_delayed_return (line 113) | async fn test_delayed_return() {
  function test_sleep (line 123) | async fn test_sleep() {

FILE: pingora-timeout/src/lib.rs
  type ToTimeout (line 51) | pub trait ToTimeout {
    method timeout (line 52) | fn timeout(&self) -> Pin<Box<dyn Future<Output = ()> + Send + Sync>>;
    method create (line 53) | fn create(d: Duration) -> Self;
    method timeout (line 62) | fn timeout(&self) -> Pin<Box<dyn Future<Output = ()> + Send + Sync>> {
    method create (line 66) | fn create(d: Duration) -> Self {
  type TokioTimeout (line 59) | pub struct TokioTimeout(Duration);
  type Elapsed (line 73) | pub struct Elapsed;
    method fmt (line 76) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function tokio_timeout (line 88) | pub fn tokio_timeout<T>(duration: Duration, future: T) -> Timeout<T, Tok...
  function new_with_delay (line 111) | pub(crate) fn new_with_delay(value: T, d: Duration) -> Timeout<T, F> {
  type Output (line 125) | type Output = Result<T::Output, Elapsed>;
  method poll (line 127) | fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::...
  function test_timeout (line 151) | async fn test_timeout() {
  function test_instantly_return (line 158) | async fn test_instantly_return() {
  function test_delayed_return (line 165) | async fn test_delayed_return() {

FILE: pingora-timeout/src/timer.rs
  constant RESOLUTION_MS (line 39) | const RESOLUTION_MS: u64 = 10;
  constant RESOLUTION_DURATION (line 40) | const RESOLUTION_DURATION: Duration = Duration::from_millis(RESOLUTION_MS);
  function round_to (line 44) | fn round_to(raw: u128, resolution: u128) -> u128 {
  type Time (line 49) | struct Time(u128);
    method from (line 52) | fn from(raw_ms: u128) -> Self {
    method from (line 58) | fn from(d: Duration) -> Self {
    method not_after (line 64) | pub fn not_after(&self, ts: u128) -> bool {
  type TimerStub (line 70) | pub struct TimerStub(Arc<Notify>, Arc<AtomicBool>);
    method poll (line 74) | pub async fn poll(self) {
  type Timer (line 82) | struct Timer(Arc<Notify>, Arc<AtomicBool>);
    method new (line 85) | pub fn new() -> Self {
    method fire (line 89) | pub fn fire(&self) {
    method subscribe (line 94) | pub fn subscribe(&self) -> TimerStub {
  type TimerManager (line 100) | pub struct TimerManager {
    method new (line 125) | pub fn new() -> Self {
    method clock_thread (line 130) | pub(crate) fn clock_thread(&self) {
    method should_i_start_clock (line 168) | pub(crate) fn should_i_start_clock(&self) -> bool {
    method is_clock_running (line 181) | pub(crate) fn is_clock_running(&self) -> Result<(), i64> {
    method register_timer (line 194) | pub fn register_timer(&self, duration: Duration) -> TimerStub {
    method is_paused_for_fork (line 224) | fn is_paused_for_fork(&self) -> bool {
    method pause_for_fork (line 234) | pub fn pause_for_fork(&self) {
    method unpause (line 243) | pub fn unpause(&self) {
  constant DELAYS_SEC (line 110) | const DELAYS_SEC: i64 = 2;
  method default (line 113) | fn default() -> Self {
  function test_round (line 253) | fn test_round() {
  function test_time (line 260) | fn test_time() {
  function test_timer_manager (line 270) | async fn test_timer_manager() {
  function test_timer_manager_start_check (line 287) | fn test_timer_manager_start_check() {
  function test_timer_manager_watchdog (line 295) | fn test_timer_manager_watchdog() {
  function test_timer_manager_pause (line 307) | async fn test_timer_manager_pause() {

FILE: pingora/examples/app/echo.rs
  type EchoApp (line 36) | pub struct EchoApp;
  method process_new (line 40) | async fn process_new(
  type HttpEchoApp (line 58) | pub struct HttpEchoApp;
  method response (line 62) | async fn response(&self, http_stream: &mut ServerSession) -> Response<Ve...

FILE: pingora/examples/app/proxy.rs
  type ProxyApp (line 28) | pub struct ProxyApp {
    method new (line 39) | pub fn new(proxy_to: BasicPeer) -> Self {
    method duplex (line 46) | async fn duplex(&self, mut server_session: Stream, mut client_session:...
  type DuplexEvent (line 33) | enum DuplexEvent {
  method process_new (line 86) | async fn process_new(

FILE: pingora/examples/client.rs
  function main (line 19) | async fn main() -> Result<()> {

FILE: pingora/examples/server.rs
  type ExampleBackgroundService (line 35) | pub struct ExampleBackgroundService;
  method start (line 38) | async fn start(&self, mut shutdown: ShutdownWatch) {
  type DynamicCert (line 60) | pub(super) struct DynamicCert {
    method new (line 66) | pub(super) fn new(cert: &str, key: &str) -> Box<Self> {
    method certificate_callback (line 78) | async fn certificate_callback(&self, ssl: &mut pingora::tls::ssl::SslR...
  constant USAGE (line 86) | const USAGE: &str = r#"
  function main (line 110) | pub fn main() {

FILE: pingora/examples/service/echo.rs
  function echo_service (line 19) | pub fn echo_service() -> Service<EchoApp> {
  function echo_service_http (line 23) | pub fn echo_service_http() -> Service<HttpServer<HttpEchoApp>> {

FILE: pingora/examples/service/proxy.rs
  function proxy_service (line 20) | pub fn proxy_service(addr: &str, proxy_addr: &str) -> Service<ProxyApp> {
  function proxy_service_tls (line 30) | pub fn proxy_service_tls(

FILE: tinyufo/benches/bench_hit_ratio.rs
  constant ITEMS (line 18) | const ITEMS: usize = 10_000;
  constant ITERATIONS (line 19) | const ITERATIONS: usize = 5_000_000;
  function bench_one (line 21) | fn bench_one(zip_exp: f64, cache_size_percent: f32) {
  function main (line 105) | fn main() {

FILE: tinyufo/benches/bench_memory.rs
  constant ITERATIONS (line 21) | const ITERATIONS: usize = 5_000_000;
  function bench_lru (line 23) | fn bench_lru(zip_exp: f64, items: usize, cache_size_percent: f32) {
  function bench_moka (line 39) | fn bench_moka(zip_exp: f64, items: usize, cache_size_percent: f32) {
  function bench_quick_cache (line 55) | fn bench_quick_cache(zip_exp: f64, items: usize, cache_size_percent: f32) {
  function bench_tinyufo (line 71) | fn bench_tinyufo(zip_exp: f64, items: usize, cache_size_percent: f32) {
  function bench_tinyufo_compact (line 87) | fn bench_tinyufo_compact(zip_exp: f64, items: usize, cache_size_percent:...
  function main (line 143) | fn main() {

FILE: tinyufo/benches/bench_perf.rs
  constant ITEMS (line 21) | const ITEMS: usize = 100;
  constant ITERATIONS (line 23) | const ITERATIONS: usize = 5_000_000;
  constant THREADS (line 24) | const THREADS: usize = 8;
  function main (line 79) | fn main() {

FILE: tinyufo/src/buckets.rs
  type Compact (line 24) | pub struct Compact<T>(Box<[SkipMap<Key, Bucket<T>>]>);
  function new (line 28) | pub fn new(total_items: usize, items_per_shard: usize) -> Self {
  function get (line 39) | pub fn get(&self, key: &Key) -> Option<Entry<'_, Key, Bucket<T>>> {
  function get_map (line 44) | pub fn get_map<V, F: FnOnce(Entry<Key, Bucket<T>>) -> V>(&self, key: &Ke...
  function insert (line 49) | fn insert(&self, key: Key, value: Bucket<T>) -> Option<()> {
  function remove (line 56) | fn remove(&self, key: &Key) {
  type Fast (line 63) | pub struct Fast<T>(HashMap<Key, Bucket<T>, RandomState>);
  function new (line 66) | pub fn new(total_items: usize) -> Self {
  function get_map (line 73) | pub fn get_map<V, F: FnOnce(&Bucket<T>) -> V>(&self, key: &Key, f: F) ->...
  function insert (line 79) | fn insert(&self, key: Key, value: Bucket<T>) -> Option<()> {
  function remove (line 84) | fn remove(&self, key: &Key) {
  type Buckets (line 90) | pub enum Buckets<T> {
  function new_fast (line 96) | pub fn new_fast(items: usize) -> Self {
  function new_compact (line 100) | pub fn new_compact(items: usize, items_per_shard: usize) -> Self {
  function insert (line 104) | pub fn insert(&self, key: Key, value: Bucket<T>) -> Option<()> {
  function remove (line 111) | pub fn remove(&self, key: &Key) {
  function get_map (line 118) | pub fn get_map<V, F: FnOnce(&Bucket<T>) -> V>(&self, key: &Key, f: F) ->...
  function get_queue (line 126) | pub fn get_queue(&self, key: &Key) -> Option<bool> {
  function test_fast (line 136) | fn test_fast() {
  function test_compact (line 156) | fn test_compact() {

FILE: tinyufo/src/estimation.rs
  type Estimator (line 19) | struct Estimator {
    method optimal_paras (line 24) | fn optimal_paras(items: usize) -> (usize, usize) {
    method optimal (line 37) | fn optimal(items: usize) -> Self {
    method compact (line 42) | fn compact(items: usize) -> Self {
    method seeded (line 48) | fn seeded(items: usize) -> Self {
    method seeded_compact (line 54) | fn seeded_compact(items: usize) -> Self {
    method new (line 61) | pub fn new(hashes: usize, slots: usize, random: impl Fn() -> RandomSta...
    method incr (line 76) | pub fn incr<T: Hash>(&self, key: T) -> u8 {
    method get (line 88) | pub fn get<T: Hash>(&self, key: T) -> u8 {
    method age (line 100) | pub fn age(&self, shift: u8) {
  function incr_no_overflow (line 112) | fn incr_no_overflow(var: &AtomicU8) -> (u8, u8) {
  type TinyLfu (line 136) | pub(crate) struct TinyLfu {
    method get (line 143) | pub fn get<T: Hash>(&self, key: T) -> u8 {
    method incr (line 147) | pub fn incr<T: Hash>(&self, key: T) -> u8 {
    method new (line 160) | pub fn new(cache_size: usize) -> Self {
    method new_compact (line 169) | pub fn new_compact(cache_size: usize) -> Self {
    method new_seeded (line 179) | pub fn new_seeded(cache_size: usize) -> Self {
    method new_compact_seeded (line 189) | pub fn new_compact_seeded(cache_size: usize) -> Self {
  function test_cmk_paras (line 204) | fn test_cmk_paras() {
  function test_tiny_lfu (line 212) | fn test_tiny_lfu() {

FILE: tinyufo/src/lib.rs
  constant SMALL (line 36) | const SMALL: bool = false;
  constant MAIN (line 37) | const MAIN: bool = true;
  type Location (line 41) | struct Location(AtomicBool);
    method new_small (line 44) | fn new_small() -> Self {
    method value (line 48) | fn value(&self) -> bool {
    method is_main (line 52) | fn is_main(&self) -> bool {
    method move_to_main (line 56) | fn move_to_main(&self) {
  constant USES_CAP (line 63) | const USES_CAP: u8 = 3;
  type Uses (line 66) | struct Uses(AtomicU8);
    method inc_uses (line 69) | pub fn inc_uses(&self) -> u8 {
    method decr_uses (line 88) | pub fn decr_uses(&self) -> u8 {
    method uses (line 105) | pub fn uses(&self) -> u8 {
  type Key (line 110) | type Key = u64;
  type Weight (line 111) | type Weight = u16;
  type KV (line 115) | pub struct KV<T> {
  type Bucket (line 124) | pub struct Bucket<T> {
  constant SMALL_QUEUE_PERCENTAGE (line 131) | const SMALL_QUEUE_PERCENTAGE: f32 = 0.1;
  type FiFoQueues (line 133) | struct FiFoQueues<T> {
  function admit (line 149) | fn admit(
  function evict_to_limit (line 246) | fn evict_to_limit(&self, extra_weight: Weight, buckets: &Buckets<T>) -> ...
  function evict_one (line 267) | fn evict_one(&self, buckets: &Buckets<T>) -> Option<KV<T>> {
  function small_weight_limit (line 281) | fn small_weight_limit(&self) -> usize {
  function evict_one_from_small (line 285) | fn evict_one_from_small(&self, buckets: &Buckets<T>) -> Option<KV<T>> {
  function evict_one_from_main (line 323) | fn evict_one_from_main(&self, buckets: &Buckets<T>) -> Option<KV<T>> {
  type TinyUfo (line 357) | pub struct TinyUfo<K, T> {
  function new (line 366) | pub fn new(total_weight_limit: usize, estimated_size: usize) -> Self {
  function new_compact (line 388) | pub fn new_compact(total_weight_limit: usize, estimated_size: usize) -> ...
  function get (line 411) | pub fn get(&self, key: &K) -> Option<T> {
  function put (line 422) | pub fn put(&self, key: K, data: T, weight: Weight) -> Vec<KV<T>> {
  function remove (line 430) | pub fn remove(&self, key: &K) -> Option<T> {
  function force_put (line 469) | pub fn force_put(&self, key: K, data: T, weight: Weight) -> Vec<KV<T>> {
  function peek_queue (line 475) | fn peek_queue(&self, key: K) -> Option<bool> {
  function test_uses (line 486) | fn test_uses() {
  function test_evict_from_small (line 503) | fn test_evict_from_small() {
  function test_evict_from_small_to_main (line 528) | fn test_evict_from_small_to_main() {
  function test_evict_reentry (line 565) | fn test_evict_reentry() {
  function test_evict_entry_denied (line 599) | fn test_evict_entry_denied() {
  function test_force_put (line 629) | fn test_force_put() {
  function test_evict_from_main (line 660) | fn test_evict_from_main() {
  function test_evict_from_small_compact (line 699) | fn test_evict_from_small_compact() {
  function test_evict_from_small_to_main_compact (line 724) | fn test_evict_from_small_to_main_compact() {
  function test_remove (line 760) | fn test_remove() {