* Prevent leaking a cache item's InputStreams when metadata read fails.
 * Use a string to identify TLS versions in routes.
 * Add frame logger for HTTP/2.
 * Replacing `httpMinorVersion` with `Protocol`. Expose HTTP/1.0 as a potential protocol.
 * Use `Protocol` to describe framing.
 * Implement write timeouts for HTTP/1.1 streams.
 * Avoid use of SPDY stream ID 1, as that's typically used for UPGRADE.
 * Support OAuth in `Authenticator`.

```
INFO: Sending request http://www.publicobject.com/helloworld.txt on Connection{www.publicobject.com:80, proxy=DIRECT hostAddress=54.187.32.157 cipherSuite=none protocol=http/1.1}
User-Agent: OkHttp Example
Host: www.publicobject.com
Connection: Keep-Alive
Accept-Encoding: gzip

INFO: Received response for http://www.publicobject.com/helloworld.txt in 115.6ms

    return delegate!!.localPrincipal
  }

  override fun getCipherSuite(): String {
    return delegate!!.cipherSuite
  }

  override fun getProtocol(): String {
    return delegate!!.protocol
  }

  override fun getPeerHost(): String {
    return delegate!!.peerHost
  }

  override fun getPeerPort(): Int {
    return delegate!!.peerPort
  }

    }

    //    public void addProxy( String protocol, String host, int port, String username, String password,
    //                          String nonProxyHosts )
    //    {
    //        ProxyInfo proxyInfo = new ProxyInfo();
    //        proxyInfo.setHost( host );
    //        proxyInfo.setType( protocol );
    //        proxyInfo.setPort( port );

   * [rfc_2817]: http://www.ietf.org/rfc/rfc2817.txt
   */
  fun requiresTunnel(): Boolean {
    if (proxy.type() != Proxy.Type.HTTP) return false
    return (address.sslSocketFactory != null) ||
      (Protocol.H2_PRIOR_KNOWLEDGE in address.protocols)
  }

  override fun equals(other: Any?): Boolean {
    return other is Route &&
      other.address == address &&
      other.proxy == proxy &&
      other.socketAddress == socketAddress
  }

				if errors.Is(err, io.EOF) {
					log.Debug("ztunnel EOF")
					return nil
				}
				return err
			case err == nil:
				log.Warn("ztunnel protocol error, unexpected message")
				return fmt.Errorf("ztunnel protocol error, unexpected message")
			default:
				// we get here if error is deadline exceeded, which means ztunnel is alive.
			}

		case <-ctx.Done():
			return nil
		}
	}

    val request =
      Request.Builder()
        .url("https://localhost:1/")
        .build()
    val interceptorResponse =
      Response.Builder()
        .request(request)
        .protocol(Protocol.HTTP_1_1)
        .code(200)
        .message("Intercepted!")
        .body("abc".toResponseBody("text/plain; charset=utf-8".toMediaType()))
        .build()
    client =
      client.newBuilder()

                              "log_format": {
                                "text_format_source": {

    CONTAINER_IP_ADDR=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' tf)
    netsh advfirewall firewall add rule name="Allow Metadata Proxy" dir=in action=allow protocol=TCP localport=80 remoteip="$CONTAINER_IP_ADDR"
  fi

fi

	})

	fmt.Fprintln(w, "NAMESPACE\tPOD NAME\tADDRESS\tNODE\tWAYPOINT\tPROTOCOL")

	for _, wl := range verifiedWorkloads {
		address := strings.Join(wl.WorkloadIPs, ",")
		if len(address) == 0 {
			address = wl.Hostname
		}
		waypoint := waypointName(wl, zDump.Services)
		fmt.Fprintf(w, "%v\t%v\t%v\t%v\t%v\t%v\n",
			wl.Namespace, wl.Name, address, wl.Node, waypoint, wl.Protocol)

	}
	return w.Flush()
}