$FLUENTBIT_CONFIG = @'
[SERVICE]
    Flush         5
    Grace         120
    Log_Level     info
    Log_File      /var/log/fluentbit.log
    Daemon        off
    Parsers_File  parsers.conf
    HTTP_Server   off
    HTTP_Listen   0.0.0.0
    HTTP_PORT     2020
    plugins_file plugins.conf

    # Storage
    # =======
    # Fluent Bit can use memory and filesystem buffering based mechanisms
    #

    }
  }

  companion object {
    val logger: Logger = Logger.getLogger(Http2Server::class.java.name)

    @JvmStatic
    fun main(args: Array<String>) {
      if (args.size != 1 || args[0].startsWith("-")) {
        println("Usage: Http2Server <base directory>")
        return
      }
      val server =
        Http2Server(
          File(args[0]),
          localhost().sslContext().socketFactory,

import okhttp3.mockwebserver.MockWebServer;
import okhttp3.tls.HandshakeCertificates;
import okhttp3.tls.HeldCertificate;

/**
 * Create an HTTPS server with a self-signed certificate that OkHttp trusts.
 */
public class HttpsServer {
  public void run() throws Exception {
    HeldCertificate localhostCertificate = new HeldCertificate.Builder()
        .addSubjectAlternativeName("localhost")
        .build();

 */
class HttpServer extends ServerWithExpectations implements HttpServerFixture {

    private final static Logger logger = LoggerFactory.getLogger(HttpServer.class)

    protected Matcher expectedUserAgent = null

    List<ServerExpectation> expectations = []

    boolean chunkedTransfer = false

func TestDownloadReleaseData(t *testing.T) {
	httpServer1 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
	defer httpServer1.Close()
	httpServer2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "fbe246edbd382902db9a4035df7dce8cb441357d minio.RELEASE.2016-10-07T01-16-39Z")
	}))
	defer httpServer2.Close()

     */
    public void configure(TestKeyStore testKeyStore, boolean needClientAuth, Predicate<String> tlsProtocolFilter) {
        HttpsServer httpsServer = (HttpsServer) this.server;
        SSLContext context = testKeyStore.asServerSSLContext();
        httpsServer.setHttpsConfigurator(new HttpsConfigurator(context) {
            @Override
            public void configure(HttpsParameters params) {
                SSLContext c = getSSLContext();

	nsn  types.NamespacedName
	port uint16

	httpServers []httpServer

	endpoints int // number of local endpoints for a service
}

// listenAll opens health check port on all the addresses provided
func (hcI *hcInstance) listenAndServeAll(hcs *server) error {
	var err error
	var listener net.Listener

	hcI.httpServers = make([]httpServer, 0, len(hcs.nodeIPs))

		// use ReadHeaderTimeout instead of ReadTimeout.
		s.httpServer.ReadTimeout = 0
		s.httpServer.ReadHeaderTimeout = 30 * time.Second
		s.httpServer.Handler = multiplexHandler
	}

	if args.ServerOptions.MonitoringAddr == "" {
		s.monitoringMux = s.httpMux
		log.Infof("initializing Istiod admin server multiplexed on httpAddr %v", s.httpServer.Addr)
	} else {
		log.Info("initializing Istiod admin server")
	}
}

    @Rule HttpServer httpServer = new HttpServer()
    @Subject HttpClientHelper client = new HttpClientHelper(new DocumentationRegistry(), httpSettings)

    def "throws exception if socket timeout is reached"() {
        given:
        httpServer.expectGetBlocking("/")
        httpServer.start()

        when:
        client.performRequest(new HttpGet("${httpServer.uri}/"), false)

        then:

import org.gradle.internal.logging.ConfigureLogging
import org.gradle.test.fixtures.server.http.HttpServer
import org.junit.Rule
import spock.lang.Specification

import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletResponse

class CookieHeaderTest extends Specification {

    @Rule
    HttpServer httpServer = new HttpServer()
    CollectingTestOutputEventListener listener = new CollectingTestOutputEventListener()