@Override
public HttpHandler getServlet() {
    return exchange -> {
        final ByteArrayOutputStream response = new ByteArrayOutputStream(1 << 20);
        final OutputStreamWriter osw = new OutputStreamWriter(response);
        textformat.write004(osw,registry.metricFamilySamples());
        osw.flush();
        osw.close();
        response.flush();
        response.close();

        exchange.getResponseHeaders().set("Content-Type",textformat.CONTENT_TYPE_004);
        exchange.getResponseHeaders().set("Content-Length",String.valueOf(response.size()));
        exchange.sendResponseHeaders(200,response.size());
        response.writeto(exchange.getResponseBody());
        exchange.close();
    };
}

public static void initServer() throws Exception {
    String portstring = System.getProperty("port.number");
    port = portstring != null ? Integer.parseInt(portstring) : 0;
    portstring = System.getProperty("port.number1");
    proxyPort = portstring != null ? Integer.parseInt(portstring) : 0;

    Logger logger = Logger.getLogger("com.sun.net.httpserver");
    ConsoleHandler ch = new ConsoleHandler();
    logger.setLevel(Level.ALL);
    ch.setLevel(Level.ALL);
    logger.addHandler(ch);
    String root = System.getProperty ("test.src")+ "/docs";
    InetSocketAddress addr = new InetSocketAddress (port);
    s1 = HttpServer.create (addr,0);
    if (s1 instanceof HttpsServer) {
        throw new RuntimeException ("should not be httpsserver");
    }
    HttpHandler h = new FileServerHandler (root);
    HttpContext c = s1.createContext ("/files",h);

    HttpHandler h1 = new RedirectHandler ("/redirect");
    HttpContext c1 = s1.createContext ("/redirect",h1);

    executor = Executors.newCachedThreadPool();
    s1.setExecutor (executor);
    s1.start();

    if (port == 0)
        port = s1.getAddress().getPort();
    else {
        if (s1.getAddress().getPort() != port)
            throw new RuntimeException("Error wrong port");
        System.out.println("Port was assigned by Driver");
    }
    System.out.println("HTTP server port = " + port);
    httproot = "http://127.0.0.1:" + port + "/files/";
    redirectroot = "http://127.0.0.1:" + port + "/redirect/";
    uri = new URI(httproot);
    fileuri = httproot + "foo.txt";
}

static HttpServer createHttpsServer() throws IOException,NoSuchAlgorithmException {
    HttpsServer server = com.sun.net.httpserver.HttpsServer.create();
    HttpContext context = server.createContext(PATH);
    context.setHandler(new HttpHandler() {
        @Override
        public void handle(HttpExchange he) throws IOException {
            he.getResponseHeaders().add("encoding","UTF-8");
            he.sendResponseHeaders(200,RESPONSE.length());
            he.getResponseBody().write(RESPONSE.getBytes(StandardCharsets.UTF_8));
            he.close();
        }
    });

    server.setHttpsConfigurator(new Configurator(SSLContext.getDefault()));
    server.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(),0),0);
    return server;
}

public static HTTPTestServer createServer(HttpProtocolType protocol,HttpAuthType authType,HttpTestAuthenticator auth,HttpSchemeType schemeType,HttpHandler delegate,String path)
        throws IOException {
    Objects.requireNonNull(authType);
    Objects.requireNonNull(auth);

    HttpServer impl = createHttpServer(protocol);
    final HTTPTestServer server = new HTTPTestServer(impl,null,delegate);
    final HttpHandler hh = server.createHandler(schemeType,auth,authType);
    HttpContext ctxt = impl.createContext(path,hh);
    server.configureAuthentication(ctxt,schemeType,authType);
    impl.start();
    return server;
}

public static HTTPTestServer createProxy(HttpProtocolType protocol,String path)
        throws IOException {
    Objects.requireNonNull(authType);
    Objects.requireNonNull(auth);

    HttpServer impl = createHttpServer(protocol);
    final HTTPTestServer server = protocol == HttpProtocolType.HTTPS
            ? new HttpsProxyTunnel(impl,delegate)
            : new HTTPTestServer(impl,authType);
    impl.start();

    return server;
}

/**
 * run
 */
public void run() {
    HttpServer server = null;
    try {
        server = HttpServer.create(new InetSocketAddress(16358),0);
    } catch (IOException e) {
        Basic.caught(e);
    }
    server.createContext("/start",new HttpHandler() {
        public void handle(HttpExchange httpExchange) throws IOException {
            URI uri = httpExchange.getRequestURI();
            System.err.println("URI: " + uri);

            String command = uri.toString().substring(uri.toString().indexOf('?') + 1);
            System.err.println("Command: " + command);

            String response = "ok";
            httpExchange.sendResponseHeaders(200,2);
            OutputStream outputStream = httpExchange.getResponseBody();
            outputStream.write(response.getBytes());
            outputStream.close();
        }
    });
    server.setExecutor(null);
    server.start();
}

public void run() {
    try {
        HttpServer server = HttpServer.create(new InetSocketAddress(port),0);
        server.createContext("/",new HttpHandler() {
            @Override
            public void handle(HttpExchange t) throws IOException {
                System.out.println(t.getRequestURI());
                String name = LockServer.validateRequest(LockServer.this.gson,t);
                if (name == null) {
                    return;
                }
                System.out.println("Lock name is: " + name);
                LockServer.this.handleLockServe(name,t);
            }
        });
        server.start();
    } catch (IOException ex) {
        ex.printstacktrace();
    }
}

public MockarangoServer(int port) throws IOException {
    server = HttpServer.create(new InetSocketAddress(port),0);
    server.createContext("/",new HttpHandler() {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            final String req = exchange.getRequestMethod() + " " + exchange.getRequestURI();
            final arangoResponse response = responses.get(req);
            if (response != null) {
                exchange.sendResponseHeaders(response.status,response.body != null ? response.body.length() : 0);
                if (response.body != null) {
                    final OutputStream out = exchange.getResponseBody();
                    out.write(response.body.getBytes());
                    out.close();
                }
            }
        }
    });
    server.setExecutor(null);
}

@Before
public void start() throws IOException {
    final String path = "/1234.xml";

    // create the HttpServer
    InetSocketAddress address = new InetSocketAddress(serverAddress,0);
    httpServer = com.sun.net.httpserver.HttpServer.create(address,0);
    // create and register our handler
    HttpHandler handler = new ConfigurableHttpHandler(serverResponse);
    httpServer.createContext(path,handler);

    // start the server
    httpServer.start();
    port = httpServer.getAddress().getPort();
    LOG.debug("started http server {}:{} with handler {}",serverAddress,port,handler);

    httpAddress = String.format("http://%s:%d/1234.xml",port);
    LOG.debug("test url is: {}",httpAddress);
}

private static HttpHandler createHttpExchange(String pathToServe) {
    return httpExchange -> {
        String requestUri = httpExchange.getRequestURI().toString();

        String name = pathToServe + requestUri;
        name = name.replaceFirst("/+","/");
        URL resource = HttpServerFromresourceInner.class.getResource(name);

        try (OutputStream os = httpExchange.getResponseBody()) {
            if (resource == null) {
                log.warn("Could not find " + requestUri);
                httpExchange.sendResponseHeaders(404,0);
            } else {
                byte[] bytes = Files.readAllBytes(Paths.get(resource.getFile()));
                httpExchange.sendResponseHeaders(200,bytes.length);

                os.write(bytes);
            }
        }
    };
}

private void startHTTPServer() throws IOException {
   Assert.assertNull(httpServer);
   InetSocketAddress address = new InetSocketAddress("127.0.0.1",8080);
   httpServer = HttpServer.create(address,100);
   httpServer.start();
   httpServer.createContext("/",new HttpHandler() {
      @Override
      public void handle(HttpExchange t) throws IOException {
         String response = "<html><body><b>This is a unit test</b></body></html>";
         t.sendResponseHeaders(200,response.length());
         OutputStream os = t.getResponseBody();
         os.write(response.getBytes());
         os.close();
      }
   });
}

@Test
public void restGatewayReferenceTimeout() throws Exception {
    HttpServer httpServer = HttpServer.create(new InetSocketAddress(8090),10);
    httpServer.setExecutor(null); // creates a default executor
    httpServer.start();
    HttpContext httpContext = httpServer.createContext("/forever",new HttpHandler() {
        @Override
        public void handle(HttpExchange exchange) {
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException ie) {
                    //Ignore
        }}});
    try {
        Message responseMsg = _consumerService2.operation("addGreeter").sendInOut("magesh");
    } catch (Exception e) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        e.printstacktrace(new PrintStream(baos));
        Assert.assertTrue(baos.toString().contains("SocketTimeoutException: Read timed out"));
    }
    httpServer.stop(0);
}

@Test
public void soapGatewayReferenceTimeout() throws Exception {
    Element input = SOAPUtil.parseAsDom("<test:sayHello xmlns:test=\"urn:switchyard-component-soap:test-ws:1.0\">"
                 + "   <arg0>Hello</arg0>"
                 + "</test:sayHello>").getDocumentElement();
    HttpServer httpServer = HttpServer.create(new InetSocketAddress(8090),new HttpHandler() {
        public void handle(HttpExchange exchange) {
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException ie) {
                    //Ignore
        }}});
    try {
        Message responseMsg = _consumerService3.operation("sayHello").sendInOut(input);
    } catch (Exception e) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        e.printstacktrace(new PrintStream(baos));
        Assert.assertTrue(baos.toString().contains("SocketTimeoutException: Read timed out"));
    }
    httpServer.stop(0);
}

public PiEzo() throws IOException
{        
    InetSocketAddress anyhost = new InetSocketAddress(2111);        
    server = HttpServer.create(anyhost,0);

    HttpHandler userInterfaceHttpHander = new ClassPathResourceHttpHandler();
    HttpHandler songsHttpHandler = new SongListHttpHander();
    HttpHandler playSongHttpHandler = new PlaySongHttpHandler();
    HttpHandler quitHttpHandler = new EndOfRunHttpHandler(server);
    HttpHandler rtttlHttpHandler = new RtttlHttpHandler();

    server.createContext("/",userInterfaceHttpHander);
    server.createContext("/play/",playSongHttpHandler);
    server.createContext("/quit",quitHttpHandler);
    server.createContext("/rtttl",rtttlHttpHandler);
    server.createContext("/songs",songsHttpHandler);
}

public static synchronized void startOrUpdate(InetSocketAddress addr,String filename,HttpHandler handler)
            throws IOException {
        if (addr == null) {
            throw new IllegalArgumentException("InetSocketAddress was null for HttpServer");
        }
        if (filename == null) {
            throw new IllegalArgumentException("filename was null for HttpServer");
        }
        boolean toStart = false;
        if (instance == null) {
            instance = new JwHttpServer();
            JwHttpServer.addr = addr;

            server = HttpServer.create(addr,/*system default backlog for TCP connections*/ 0);
//            server.setExecutor(Executors.newCachedThreadPool());
            toStart = true;
        }
        HttpContext context = server.createContext(filename,handler);
        context.getFilters().add(new ParameterFilter());
        if (toStart) {
            server.start();
        }
    }

private HttpServer startServer(final String... response) throws IOException {
  HttpServer server = HttpServer.create(new InetSocketAddress(0),0);
  server.createContext("/").setHandler(
      new HttpHandler() {
        int responseIndex = 0;
        public void handle(HttpExchange exchange) throws IOException {
          byte[] responseBytes;
          if (responseIndex < response.length) {
            responseBytes = response[responseIndex].getBytes(UTF_8);
            responseIndex++;
          } else {
            responseBytes = new byte[0];
          }
          exchange.sendResponseHeaders(200,responseBytes.length);
          OutputStream out = exchange.getResponseBody();
          IOHelper.copyStream(new ByteArrayInputStream(responseBytes),out);
          exchange.close();
        }
      });
  server.start();
  return server;
}

private void createContextAndRegisterHandler() {
    httpServer.createContext("/",new HttpHandler() {
        public void handle(HttpExchange exchange) throws IOException {
            System.out.println(exchange.getRequestMethod() + " " + exchange.getRequestURI());
            switch (exchange.getRequestMethod()) {
                case HttpMethods.GET:
                    handleGet(exchange);
                    break;
                case HttpMethods.PUT:
                    handlePut(exchange);
                    break;
                case HttpMethods.DELETE:
                    handleDelete(exchange);
                    break;
                default:
                    System.out.println("Don't kNow how to " + exchange.getRequestMethod());
                    throw new UnsupportedOperationException("Don't kNow how to " + exchange.getRequestMethod());
            }
        }
    });
}

private HttpHandler createHandler(final int status,final TableSizeInfo tableSize,final int sleepTimeMs) {
  return new HttpHandler() {
    @Override
    public void handle(HttpExchange httpExchange)
        throws IOException {
      if (sleepTimeMs > 0) {
        try {
          Thread.sleep(sleepTimeMs);
        } catch (InterruptedException e) {
          LOGGER.info("Handler interrupted during sleep");
        }
      }
      String json = new ObjectMapper().writeValueAsstring(tableSize);
      httpExchange.sendResponseHeaders(status,json.length());
      OutputStream responseBody = httpExchange.getResponseBody();
      responseBody.write(json.getBytes());
      responseBody.close();
    }
  };
}

private HttpHandler createHandler(final int status,final String msg,final int sleepTimeMs) {
  return new HttpHandler() {
    @Override
    public void handle(HttpExchange httpExchange)
        throws IOException {
      if (sleepTimeMs > 0) {
        try {
          Thread.sleep(sleepTimeMs);
        } catch (InterruptedException e) {
          LOGGER.info("Handler interrupted during sleep");
        }
      }
      httpExchange.sendResponseHeaders(status,msg.length());
      OutputStream responseBody = httpExchange.getResponseBody();
      responseBody.write(msg.getBytes());
      responseBody.close();
    }
  };
}

public void start(HttpsServerProperties properties,SSLContext sslContext,HttpHandler handler) throws Exception {
    logger.info("start {}",properties);
    executor = new ThreadPoolExecutor(100,200,60,TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(10));
    name = handler.getClass().getSimpleName();
    executor.setRejectedExecutionHandler(this);        
    InetSocketAddress socketAddress = new InetSocketAddress(properties.getPort());
    httpsServer = HttpsServer.create(socketAddress,16);
    httpsServer.setHttpsConfigurator(HttpsConfiguratorFactory.
            createHttpsConfigurator(sslContext,properties.isClientAuth()));
    httpsServer.setExecutor(executor);
    httpsServer.createContext("/",handler);
    httpsServer.start();
    logger.info("init {}",properties);
}

public static void main(String[] args) throws Exception {
    HttpServer server = HttpServer.create(new InetSocketAddress(8000),0);
    server.createContext("/simple",new HttpHandler() {
        @Override
        public void handle(HttpExchange t) throws IOException {
            try {
                TimeUnit.MILLISECONDS.sleep(100);
            } catch (InterruptedException e) {
                // ignore
            }
            String response = "This is the response";
            t.sendResponseHeaders(200,response.length());
            OutputStream os = t.getResponseBody();
            os.write(response.getBytes());
            os.close();
        }
    });
    server.setExecutor(null); // creates a default executor
    server.start();
}

private static void startHTTPServer() throws IOException {
  httpServer = HttpServer.create( new InetSocketAddress( JobEntryHTTP_PDI208_Test.HTTP_HOST,JobEntryHTTP_PDI208_Test.HTTP_PORT ),10 );
  httpServer.createContext( "/uploadFile",new HttpHandler() {
    @Override
    public void handle( HttpExchange httpExchange ) throws IOException {
      Headers h = httpExchange.getResponseHeaders();
      h.add( "Content-Type","application/octet-stream" );
      httpExchange.sendResponseHeaders( 200,0 );
      InputStream is = httpExchange.getRequestBody();
      OutputStream os = httpExchange.getResponseBody();
      int inputChar = -1;
      while ( ( inputChar = is.read() ) >= 0 ) {
        os.write( inputChar );
      }
      is.close();
      os.flush();
      os.close();
      httpExchange.close();
    }
  } );
  httpServer.start();
}

private void createContext(HttpServer server,String path,HttpHandler handler,Authenticator auth)
{
    final HttpContext context = server.createContext(path,handler);
    if( auth != null )
    {
        context.setAuthenticator(auth);
    }
    context.getFilters().addAll(filters);
}

private void registerRootbrowserView() {        
    if (httpServer == null)
        return;
    try {
        httpServer.createContext("/",new HttpHandler() {                                
            public void handle(HttpExchange exchange) throws IOException {
                String requestMethod = exchange.getRequestMethod();
                Headers responseHeaders = exchange.getResponseHeaders();
                responseHeaders.set("Content-Type","text/html");
                exchange.sendResponseHeaders(200,0);
                OutputStream responseBody = exchange.getResponseBody();

                if (requestMethod.equalsIgnoreCase("GET")) {
                    String path = exchange.getRequestURI().getPath();
                    StringWriter so = new StringWriter();

                    if (path.length() < 2) { // it is the root
                        so.append("<html><head><title>Jason Mind Inspector -- Web View</title></head><body>");
                        so.append("<iframe width=\"20%\" height=\"100%\" align=left src=\"/agents\" border=5 frameborder=0 ></iframe>");
                        so.append("<iframe width=\"78%\" height=\"100%\" align=left src=\"/agent-mind/no_ag\" name=\"am\" border=5 frameborder=0></iframe>");
                        so.append("</body></html>");
                    } else if (path.indexOf("agent-mind") >= 0) {
                        if (tryToIncludeMindInspectorForAg(path))
                            so.append("<Meta http-equiv=\"refresh\" content=0>");                                
                        else
                            so.append("unkown agent!");
                    }
                    responseBody.write(so.toString().getBytes());
                }                                
                responseBody.close();
            }
        });
    } catch (Exception e) {
        e.printstacktrace();
    }
}

private void registeragentsbrowserView() {        
    if (httpServer == null)
        return;
    try {
        httpServer.createContext("/agents",0);
                OutputStream responseBody = exchange.getResponseBody();

                if (requestMethod.equalsIgnoreCase("GET")) {
                    responseBody.write(("<html><head><title>Jason (list of agents)</title><Meta http-equiv=\"refresh\" content=\""+refreshInterval+"\" ></head><body>").getBytes());
                    responseBody.write(("<font size=\"+2\"><p>Agents</p></font>").getBytes());
                    for (String a: histories.keySet()) {
                        responseBody.write( ("- <a href=\"/agent-mind/"+a+"/latest\" target=\"am\" style=\"font-family: arial; text-decoration: none\">"+a+"</a><br/>").getBytes());                            
                    }
                }                                
                responseBody.write("<hr/>by <a href=\"http://jason.sf.net\" target=\"_blank\">Jason</a>".getBytes());
                responseBody.write("</body></html>".getBytes());
                responseBody.close();
            }
        });
    } catch (Exception e) {
        e.printstacktrace();
    }
}

public static void main(String[] args) throws Exception {
     boolean error = true;

     // Start a dummy server to return 404
     HttpServer server = HttpServer.create(new InetSocketAddress(0),0);
     HttpHandler handler = new HttpHandler() {
         public void handle(HttpExchange t) throws IOException {
             InputStream is = t.getRequestBody();
             while (is.read() != -1);
             t.sendResponseHeaders (404,-1);
             t.close();
         }
     };
     server.createContext("/",handler);
     server.start();

     // Client request
     try {
         URL url = new URL("http://localhost:" + server.getAddress().getPort());
         String name = args.length >= 2 ? args[1] : "foo.bar.Baz";
         ClassLoader loader = new urlclassloader(new URL[] { url });
         System.out.println(url);
         Class c = loader.loadClass(name);
         System.out.println("Loaded class \"" + c.getName() + "\".");
     } catch (ClassNotFoundException ex) {
         System.out.println(ex);
         error = false;
     } finally {
         server.stop(0);
     }
     if (error)
         throw new RuntimeException("No ClassNotFoundException generated");
}

/**
 * Http Server
 */
static HttpServer startHttpServer() throws IOException {
    HttpServer httpServer = HttpServer.create(new InetSocketAddress(0),0);
    HttpHandler httpHandler = new SimpleHandler();
    httpServer.createContext("/chunked/",httpHandler);
    httpServer.start();
    return httpServer;
}

public static void main(String[] args) throws Exception {
    HttpServer server = HttpServer.create(new InetSocketAddress(0),0);
    try {
        server.setExecutor(Executors.newFixedThreadPool(1));
        server.createContext(someContext,new HttpHandler() {
            @Override
            public void handle(HttpExchange msg) {
                try {
                    try {
                        msg.sendResponseHeaders(noMsgCode,-1);
                    } catch(IOException ioe) {
                        ioe.printstacktrace();
                    }
                } finally {
                    msg.close();
                }
            }
        });
        server.start();
        System.out.println("Server started at port "
                           + server.getAddress().getPort());

        runRawSocketHttpClient("localhost",server.getAddress().getPort());
    } finally {
        ((ExecutorService)server.getExecutor()).shutdown();
        server.stop(0);
    }
    System.out.println("Server finished.");
}

/**
 * Create and start the HTTP server.
 */
public DeafServer() throws IOException {
    InetSocketAddress addr = new InetSocketAddress(0);
    server = HttpServer.create(addr,0);
    HttpHandler handler = new DeafHandler();
    server.createContext("/",handler);
    server.setExecutor(Executors.newCachedThreadPool());
    server.start();
}

private HttpHandler getHttpHandler() {
    return new HttpHandler() {
        @Override
        public void handle(HttpExchange httpExchange) throws IOException {
            try {
                final Headers headers = httpExchange.getResponseHeaders();
                final String requestMethod = httpExchange.getRequestMethod().toupperCase();
                switch (requestMethod) {
                    case METHOD_GET:
                        final String responseBody = getUrlComponent(httpExchange.getRequestURI());
                        headers.set(HEADER_CONTENT_TYPE,String.format("%s; charset=%s",TYPE.getMimeType(httpExchange.getRequestURI().toString()),CHARSET));

                        final byte[] rawResponseBody = responseBody.getBytes(CHARSET);
                        httpExchange.sendResponseHeaders(STATUS_OK,rawResponseBody.length);
                        httpExchange.getResponseBody().write(rawResponseBody);
                        break;
                    case METHOD_OPTIONS:
                        headers.set(HEADER_ALLOW,ALLOWED_METHODS);
                        httpExchange.sendResponseHeaders(STATUS_OK,NO_RESPONSE_LENGTH);
                        break;
                    default:
                        headers.set(HEADER_ALLOW,ALLOWED_METHODS);
                        httpExchange.sendResponseHeaders(STATUS_METHOD_NOT_ALLOWED,NO_RESPONSE_LENGTH);
                        break;
                }
            } finally {
                httpExchange.close();
            }
        }
    };
}

public static void main(String[] args) throws Exception {
     boolean error = true;

     // Start a dummy server to return 404
     HttpServer server = HttpServer.create(new InetSocketAddress(0),handler);
     server.start();

     // Client request
     try {
         URL url = new URL("http://localhost:" + server.getAddress().getPort());
         String name = args.length >= 2 ? args[1] : "foo.bar.Baz";
         ClassLoader loader = new urlclassloader(new URL[] { url });
         System.out.println(url);
         Class c = loader.loadClass(name);
         System.out.println("Loaded class \"" + c.getName() + "\".");
     } catch (ClassNotFoundException ex) {
         System.out.println(ex);
         error = false;
     } finally {
         server.stop(0);
     }
     if (error)
         throw new RuntimeException("No ClassNotFoundException generated");
}

static void initServer() throws Exception {

        Logger logger = Logger.getLogger("com.sun.net.httpserver");
        ConsoleHandler ch = new ConsoleHandler();
        logger.setLevel(Level.SEVERE);
        ch.setLevel(Level.SEVERE);
        logger.addHandler(ch);

        String root = System.getProperty ("test.src")+ "/docs";
        InetSocketAddress addr = new InetSocketAddress (0);
        s1 = HttpServer.create (addr,0);
        if (s1 instanceof HttpsServer) {
            throw new RuntimeException ("should not be httpsserver");
        }
        s2 = HttpsServer.create (addr,0);
        HttpHandler h = new FileServerHandler(root);

        HttpContext c1 = s1.createContext("/files",h);
        HttpContext c2 = s2.createContext("/files",h);
        HttpContext c3 = s1.createContext("/echo",new EchoHandler());
        redirectHandler = new RedirectHandler("/redirect");
        redirectHandlerSecure = new RedirectHandler("/redirect");
        HttpContext c4 = s1.createContext("/redirect",redirectHandler);
        HttpContext c41 = s2.createContext("/redirect",redirectHandlerSecure);
        HttpContext c5 = s2.createContext("/echo",new EchoHandler());
        HttpContext c6 = s1.createContext("/keepalive",new KeepAliveHandler());
        redirectErrorHandler = new RedirectErrorHandler("/redirecterror");
        redirectErrorHandlerSecure = new RedirectErrorHandler("/redirecterror");
        HttpContext c7 = s1.createContext("/redirecterror",redirectErrorHandler);
        HttpContext c71 = s2.createContext("/redirecterror",redirectErrorHandlerSecure);
        delayHandler = new DelayHandler();
        HttpContext c8 = s1.createContext("/delay",delayHandler);
        HttpContext c81 = s2.createContext("/delay",delayHandler);

        executor = Executors.newCachedThreadPool();
        s1.setExecutor(executor);
        s2.setExecutor(executor);
        ctx = new SimpleSSLContext().get();
        sslparams = ctx.getSupportedSSLParameters();
        s2.setHttpsConfigurator(new Configurator(ctx));
        s1.start();
        s2.start();

        port = s1.getAddress().getPort();
        System.out.println("HTTP server port = " + port);
        httpsport = s2.getAddress().getPort();
        System.out.println("HTTPS server port = " + httpsport);
        httproot = "http://127.0.0.1:" + port + "/";
        httpsroot = "https://127.0.0.1:" + httpsport + "/";

        proxy = new ProxyServer(0,false);
        proxyPort = proxy.getPort();
        System.out.println("Proxy port = " + proxyPort);
    }

static void initServer() throws Exception {
    InetSocketAddress addr = new InetSocketAddress (0);
    s1 = HttpServer.create (addr,0);
    HttpHandler h = new Handler();

    HttpContext c1 = s1.createContext("/",h);

    executor = Executors.newCachedThreadPool();
    s1.setExecutor(executor);
    s1.start();

    port = s1.getAddress().getPort();
    uri = new URI("http://127.0.0.1:" + Integer.toString(port) + "/foo");
    System.out.println("HTTP server port = " + port);
}

public static void initServer() throws IOException {

        Logger logger = Logger.getLogger("com.sun.net.httpserver");
        ConsoleHandler ch = new ConsoleHandler();
        logger.setLevel(Level.ALL);
        ch.setLevel(Level.ALL);
        logger.addHandler(ch);

        String root = System.getProperty("test.src") + "/docs";
        InetSocketAddress addr = new InetSocketAddress(0);
        httpServer = HttpServer.create(addr,0);
        if (httpServer instanceof HttpsServer) {
            throw new RuntimeException("should not be httpsserver");
        }
        httpsServer = HttpsServer.create(addr,0);
        HttpHandler h = new FileServerHandler(root);

        HttpContext c1 = httpServer.createContext("/files",h);
        HttpContext c2 = httpsServer.createContext("/files",h);
        HttpContext c3 = httpServer.createContext("/echo",new EchoHandler());
        redirectHandler = new RedirectHandler("/redirect");
        redirectHandlerSecure = new RedirectHandler("/redirect");
        HttpContext c4 = httpServer.createContext("/redirect",redirectHandler);
        HttpContext c41 = httpsServer.createContext("/redirect",redirectHandlerSecure);
        HttpContext c5 = httpsServer.createContext("/echo",new EchoHandler());
        HttpContext c6 = httpServer.createContext("/keepalive",new KeepAliveHandler());
        redirectErrorHandler = new RedirectErrorHandler("/redirecterror");
        redirectErrorHandlerSecure = new RedirectErrorHandler("/redirecterror");
        HttpContext c7 = httpServer.createContext("/redirecterror",redirectErrorHandler);
        HttpContext c71 = httpsServer.createContext("/redirecterror",redirectErrorHandlerSecure);
        delayHandler = new DelayHandler();
        HttpContext c8 = httpServer.createContext("/delay",delayHandler);
        HttpContext c81 = httpsServer.createContext("/delay",delayHandler);

        executor = Executors.newCachedThreadPool();
        httpServer.setExecutor(executor);
        httpsServer.setExecutor(executor);
        ctx = new SimpleSSLContext().get();
        httpsServer.setHttpsConfigurator(new HttpsConfigurator(ctx));
        httpServer.start();
        httpsServer.start();

        port = httpServer.getAddress().getPort();
        System.out.println("HTTP server port = " + port);
        httpsport = httpsServer.getAddress().getPort();
        System.out.println("HTTPS server port = " + httpsport);
        httproot = "http://127.0.0.1:" + port + "/";
        httpsroot = "https://127.0.0.1:" + httpsport + "/";

        proxy = new ProxyServer(0,false);
        proxyPort = proxy.getPort();
        System.out.println("Proxy port = " + proxyPort);
    }

public static HTTPTestServer create(HttpProtocolType protocol,HttpHandler delegate)
        throws IOException {
    Objects.requireNonNull(authType);
    Objects.requireNonNull(auth);
    switch(authType) {
        // A server that performs Server Digest authentication.
        case SERVER: return createServer(protocol,authType,delegate,"/");
        // A server that pretends to be a Proxy and performs
        // Proxy Digest authentication. If protocol is HTTPS,// then this will create a HttpsProxyTunnel that will
        // handle the CONNECT request for tunneling.
        case PROXY: return createProxy(protocol,"/");
        // A server that sends 307 redirect to a server that performs
        // Digest authentication.
        // Note: 301 doesn't work here because it transforms POST into GET.
        case SERVER307: return createServerAndRedirect(protocol,HttpAuthType.SERVER,307);
        // A server that sends 305 redirect to a proxy that performs
        // Digest authentication.
        case PROXY305:  return createServerAndRedirect(protocol,HttpAuthType.PROXY,305);
        default:
            throw new InternalError("UnkNown server type: " + authType);
    }
}

public static HTTPTestServer createServerAndRedirect(
                                    HttpProtocolType protocol,HttpAuthType targetAuthType,HttpHandler targetDelegate,int code300)
        throws IOException {
    Objects.requireNonNull(targetAuthType);
    Objects.requireNonNull(auth);

    // The connection between client and proxy can only
    // be a plain connection: SSL connection to proxy
    // is not supported by our client connection.
    HttpProtocolType targetProtocol = targetAuthType == HttpAuthType.PROXY
                                      ? HttpProtocolType.HTTP
                                      : protocol;
    HTTPTestServer redirectTarget =
            (targetAuthType == HttpAuthType.PROXY)
            ? createProxy(protocol,targetAuthType,targetDelegate,"/")
            : createServer(targetProtocol,"/");
    HttpServer impl = createHttpServer(protocol);
    final HTTPTestServer redirectingServer =
             new HTTPTestServer(impl,redirectTarget,null);
    InetSocketAddress redirectAddr = redirectTarget.getAddress();
    URL locationURL = url(targetProtocol,redirectAddr,"/");
    final HttpHandler hh = redirectingServer.create300Handler(locationURL,code300);
    impl.createContext("/",hh);
    impl.start();
    return redirectingServer;
}

public HttpsProxyTunnel(HttpServer server,HTTPTestServer target,HttpHandler delegate)
        throws IOException {
    super(server,target,delegate);
    System.out.flush();
    System.err.println("WARNING: HttpsProxyTunnel is an experimental test class");
    ss = new ServerSocket(0,InetAddress.getByName("127.0.0.1"));
    start();
}

static HttpHandler createCapturingHandler(CompletableFuture<Headers> headers) {
    return new HttpHandler() {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            headers.complete(exchange.getRequestHeaders());
            exchange.sendResponseHeaders(HttpURLConnection.HTTP_OK,-1);
            exchange.close();
        }
    };
}

/**
 * Http Server
 */
static HttpServer startHttpServer() throws IOException {
    HttpServer httpServer = HttpServer.create(new InetSocketAddress(0),httpHandler);
    httpServer.start();
    return httpServer;
}

public static void main(String[] args) throws Exception {
    HttpServer server = HttpServer.create(new InetSocketAddress(0),server.getAddress().getPort());
    } finally {
        ((ExecutorService)server.getExecutor()).shutdown();
        server.stop(0);
    }
    System.out.println("Server finished.");
}

@Override @NotNull
public String getBaseAddress() {
    /*
     * Computes the Endpoint's address from the request. Use "Host" header
     * so that it has correct address(IP address or someother hostname)
     * through which the application reached the endpoint.
     *
     */
    StringBuilder strBuf = new StringBuilder();
    strBuf.append((httpExchange instanceof HttpsExchange) ? "https" : "http");
    strBuf.append("://");

    String hostHeader = httpExchange.getRequestHeaders().getFirst("Host");
    if (hostHeader != null) {
        strBuf.append(hostHeader);   // Uses Host header
    } else {
        strBuf.append(httpExchange.getLocalAddress().getHostName());
        strBuf.append(":");
        strBuf.append(httpExchange.getLocalAddress().getPort());
    }
    //Do not include URL pattern here
    //strBuf.append(httpExchange.getRequestURI().getPath());

    return strBuf.toString();
}

@Override @NotNull
public String getBaseAddress() {
    /*
     * Computes the Endpoint's address from the request. Use "Host" header
     * so that it has correct address(IP address or someother hostname)
     * through which the application reached the endpoint.
     *
     */
    StringBuilder strBuf = new StringBuilder();
    strBuf.append((httpExchange instanceof HttpsExchange) ? "https" : "http");
    strBuf.append("://");

    String hostHeader = httpExchange.getRequestHeaders().getFirst("Host");
    if (hostHeader != null) {
        strBuf.append(hostHeader);   // Uses Host header
    } else {
        strBuf.append(httpExchange.getLocalAddress().getHostName());
        strBuf.append(":");
        strBuf.append(httpExchange.getLocalAddress().getPort());
    }
    //Do not include URL pattern here
    //strBuf.append(httpExchange.getRequestURI().getPath());

    return strBuf.toString();
}

@Override @NotNull
public String getBaseAddress() {
    /*
     * Computes the Endpoint's address from the request. Use "Host" header
     * so that it has correct address(IP address or someother hostname)
     * through which the application reached the endpoint.
     *
     */
    StringBuilder strBuf = new StringBuilder();
    strBuf.append((httpExchange instanceof HttpsExchange) ? "https" : "http");
    strBuf.append("://");

    String hostHeader = httpExchange.getRequestHeaders().getFirst("Host");
    if (hostHeader != null) {
        strBuf.append(hostHeader);   // Uses Host header
    } else {
        strBuf.append(httpExchange.getLocalAddress().getHostName());
        strBuf.append(":");
        strBuf.append(httpExchange.getLocalAddress().getPort());
    }
    //Do not include URL pattern here
    //strBuf.append(httpExchange.getRequestURI().getPath());

    return strBuf.toString();
}

@Override @NotNull
public String getBaseAddress() {
    /*
     * Computes the Endpoint's address from the request. Use "Host" header
     * so that it has correct address(IP address or someother hostname)
     * through which the application reached the endpoint.
     *
     */
    StringBuilder strBuf = new StringBuilder();
    strBuf.append((httpExchange instanceof HttpsExchange) ? "https" : "http");
    strBuf.append("://");

    String hostHeader = httpExchange.getRequestHeaders().getFirst("Host");
    if (hostHeader != null) {
        strBuf.append(hostHeader);   // Uses Host header
    } else {
        strBuf.append(httpExchange.getLocalAddress().getHostName());
        strBuf.append(":");
        strBuf.append(httpExchange.getLocalAddress().getPort());
    }
    //Do not include URL pattern here
    //strBuf.append(httpExchange.getRequestURI().getPath());

    return strBuf.toString();
}

@Override @NotNull
public String getBaseAddress() {
    /*
     * Computes the Endpoint's address from the request. Use "Host" header
     * so that it has correct address(IP address or someother hostname)
     * through which the application reached the endpoint.
     *
     */
    StringBuilder strBuf = new StringBuilder();
    strBuf.append((httpExchange instanceof HttpsExchange) ? "https" : "http");
    strBuf.append("://");

    String hostHeader = httpExchange.getRequestHeaders().getFirst("Host");
    if (hostHeader != null) {
        strBuf.append(hostHeader);   // Uses Host header
    } else {
        strBuf.append(httpExchange.getLocalAddress().getHostName());
        strBuf.append(":");
        strBuf.append(httpExchange.getLocalAddress().getPort());
    }
    //Do not include URL pattern here
    //strBuf.append(httpExchange.getRequestURI().getPath());

    return strBuf.toString();
}

private URI getBaseUri(final HttpExchange exchange,final String decodedBasePath) {
    final String scheme = (exchange instanceof HttpsExchange) ? "https" : "http";

    final URI baseUri;
    try {
        final List<String> hostHeader = exchange.getRequestHeaders().get("Host");
        if (hostHeader != null) {
            baseUri = new URI(scheme + "://" + hostHeader.get(0) + decodedBasePath);
        } else {
            final InetSocketAddress addr = exchange.getLocalAddress();
            baseUri = new URI(scheme,null,addr.getHostName(),addr.getPort(),decodedBasePath,null);
        }
    } catch (final URISyntaxException ex) {
        throw new IllegalArgumentException(ex);
    }
    return baseUri;
}

@Override @NotNull
public String getBaseAddress() {
    /*
     * Computes the Endpoint's address from the request. Use "Host" header
     * so that it has correct address(IP address or someother hostname)
     * through which the application reached the endpoint.
     *
     */
    StringBuilder strBuf = new StringBuilder();
    strBuf.append((httpExchange instanceof HttpsExchange) ? "https" : "http");
    strBuf.append("://");

    String hostHeader = httpExchange.getRequestHeaders().getFirst("Host");
    if (hostHeader != null) {
        strBuf.append(hostHeader);   // Uses Host header
    } else {
        strBuf.append(httpExchange.getLocalAddress().getHostName());
        strBuf.append(":");
        strBuf.append(httpExchange.getLocalAddress().getPort());
    }
    //Do not include URL pattern here
    //strBuf.append(httpExchange.getRequestURI().getPath());

    return strBuf.toString();
}

@Override @NotNull
public String getBaseAddress() {
    /*
     * Computes the Endpoint's address from the request. Use "Host" header
     * so that it has correct address(IP address or someother hostname)
     * through which the application reached the endpoint.
     *
     */
    StringBuilder strBuf = new StringBuilder();
    strBuf.append((httpExchange instanceof HttpsExchange) ? "https" : "http");
    strBuf.append("://");

    String hostHeader = httpExchange.getRequestHeaders().getFirst("Host");
    if (hostHeader != null) {
        strBuf.append(hostHeader);   // Uses Host header
    } else {
        strBuf.append(httpExchange.getLocalAddress().getHostName());
        strBuf.append(":");
        strBuf.append(httpExchange.getLocalAddress().getPort());
    }
    //Do not include URL pattern here
    //strBuf.append(httpExchange.getRequestURI().getPath());

    return strBuf.toString();
}

@NotNull
public static Headers withoutEntityHeaders(@NotNull final HttpExchange httpExchange,@NotNull final String cacheControlHeaderValue)
{
    final Headers responseHeaders = httpExchange.getResponseHeaders();
    responseHeaders.set(ServerHeaderName,ServerHeaderValue);
    responseHeaders.set(DateHeaderName,rfc2822DateForNow());
    responseHeaders.set(ContentLanguageHeaderName,ContentLanguageHeaderValue);
    responseHeaders.set(ConnectionHeaderName,"close");
    final boolean isHttps = httpExchange instanceof HttpsExchange;
    if (isHttps)
    {
        responseHeaders.set(StrictTransportSecurityHeaderName,StrictTransportSecurityHeaderValueMaximum);
    }
    responseHeaders.set(XFrameOptionsHeaderName,"DENY");
    responseHeaders.set(XXssprotectionHeaderName,"1; mode=block");
    responseHeaders.set(XRimAutoMatchHeaderName,"none");
    responseHeaders.set(XRobotsTagHeaderName,"none");
    responseHeaders.set(AccessControlAllowOriginHeaderName,"*");
    responseHeaders.set(AccessControlAllowMethodsHeaderName,"POST,PUT,DELETE,GET,HEAD,OPTIONS");
    responseHeaders.set(AccessControlAllowHeadersHeaderName,"Authorization,Content-Type");
    responseHeaders.set(CacheControlHeaderName,cacheControlHeaderValue);
    responseHeaders.set(AcceptRangesHeaderName,"none");
    return responseHeaders;
}

@Override
public boolean isSecure() {
    return (httpExchange instanceof HttpsExchange);
}

@Override
public String getRequestScheme() {
        return (httpExchange instanceof HttpsExchange) ? "https" : "http";
}

public void handle(HttpExchange httpExchange) throws IOException {
    HttpsExchange exchange = (HttpsExchange) httpExchange;
    Boolean hasPassword = false;
    String myPassword = "";
    String myHdrUser = "";
    String myHdrMessage = "";
    String[] uriQueryList = null;

    // Get the path and query string from the URI
    URI uriData = exchange.getRequestURI();
    String uriPath = uriData.getPath();
    String uriQuery = uriData.getQuery();

    if (uriQuery != null) {
        uriQueryList = uriQuery.split("&");
    }

    // Get the headers
    Headers headers = exchange.getRequestHeaders();

    // Get the Request Method (GET/PUT)
    String requestMethod = exchange.getRequestMethod();

    // Get any data from the body,although,we just discard it,this is required
    InputStream inputStream = exchange.getRequestBody();
    while (inputStream.read() != -1) {
        inputStream.skip(0x10000);
    }
    inputStream.close();

    if (headers.containsKey("password")) {
        myPassword = headers.getFirst("password");
        if (myPassword.equals(serverPassword) || myPassword.equals("oauth:" + serverPassword)) {
            hasPassword = true;
        }
    }
    if (headers.containsKey("webauth")) {
        myPassword = headers.getFirst("webauth");
        if (myPassword.equals(serverWebAuth)) {
            hasPassword = true;
        }
    }
    if (headers.containsKey("user")) {
        myHdrUser = headers.getFirst("user");
    }
    if (headers.containsKey("message")) {
        myHdrMessage = headers.getFirst("message");
    }

    if (requestMethod.equals("GET")) {
        if (uriPath.contains("..")) {
            sendHTMLError(403,"Invalid URL",exchange);
        } else if (uriPath.startsWith("/inistore")) {
            handleIniStore(uriPath,exchange,hasPassword);
        } else if (uriPath.startsWith("/dbquery")) {
            handleDBQuery(uriPath,uriQueryList,hasPassword);
        } else if (uriPath.startsWith("/addons") || uriPath.startsWith("/logs")) {
            handleFile(uriPath,hasPassword,true);
        } else if (uriPath.equals("/playlist")) {
            handleFile("/web/playlist/index.html",false);
        } else if (uriPath.equals("/")) {
            handleFile("/web/index.html",false);
        } else {
            handleFile("/web" + uriPath,false);
        }
    }

    if (requestMethod.equals("PUT")) {
        handlePutRequest(myHdrUser,myHdrMessage,hasPassword);
    }

}

@Override
public boolean isSecure() {
    return (httpExchange instanceof HttpsExchange);
}

@Override
public String getRequestScheme() {
        return (httpExchange instanceof HttpsExchange) ? "https" : "http";
}

@Override
public boolean isSecure() {
    return (httpExchange instanceof HttpsExchange);
}

@Override
public String getRequestScheme() {
        return (httpExchange instanceof HttpsExchange) ? "https" : "http";
}

@Override
public boolean isSecure() {
    return (httpExchange instanceof HttpsExchange);
}

@Override
public String getRequestScheme() {
        return (httpExchange instanceof HttpsExchange) ? "https" : "http";
}

@Override
public boolean isSecure() {
    return (httpExchange instanceof HttpsExchange);
}

@Override
public String getRequestScheme() {
        return (httpExchange instanceof HttpsExchange) ? "https" : "http";
}

@Override
public boolean isSecure() {
    return (httpExchange instanceof HttpsExchange);
}

@Override
public String getRequestScheme() {
        return (httpExchange instanceof HttpsExchange) ? "https" : "http";
}

@Override
public String getProtocol() {
    boolean isSecure = this.ex instanceof HttpsExchange;

    return ex.getProtocol().split("/")[0].toLowerCase() + (isSecure ? "s" : "");
}

@Override
public boolean isSecure() {
    return (httpExchange instanceof HttpsExchange);
}

public SSLSession getSSLSession() {
    return ((HttpsExchange) delegate).getSSLSession();
}

public X509Certificate getPeerCertficate() throws SSLPeerUnverifiedException {
    return ((HttpsExchange) delegate).getSSLSession().getPeerCertificateChain()[0];        
}

public void startServer() throws Exception
{
    executeUpgrader();

    Authenticator auth = new MyAuthenticator(config);
    server = HttpServerProvider.provider().createHttpServer(
        new InetSocketAddress(config.getManagerDetails().getManagerPort()),50);

    AjaxState ajaxState = new AjaxStateImpl();

    createContext(server,"/",new WebrootHandler()); //$NON-NLS-1$
    createContext(server,"/pages/",new PagesHandler(config),auth); //$NON-NLS-1$
    createContext(server,"/server/",new ServerHandler(config),"/deploy/",new DeployHandler(config,ajaxState),"/ajax/",new AjaxProgressHandler(ajaxState)); //$NON-NLS-1$
    createContext(server,"/upload/",new UploadHandler(config)); //$NON-NLS-1$

    server.start();
}

@Override
public Archive<?> createAuxiliaryArchive() {
    JavaArchive arquillianPactConsumer = null;
    arquillianPactConsumer = ShrinkWrap.create(JavaArchive.class,"arquillian-pact-consumer.jar")
        // Add Core classes required in container part
        .addClasses(AbstractConsumerPactTest.class,RemoteConsumerPactTest.class,PactConsumerConfiguration.class,MockProviderConfigCreator.class,PactConsumerConfigurator.class,PactConsumerRemoteExtension.class,PactFilesCommand.class,ConsumerProviderPair.class,PactMismatchesException.class,ConsumerPactRunnerKt.class,HttpHandler.class,HttpServer.class,HttpServerProvider.class,ResolveClassAnnotation.class,StubServer.class,StubServerEnricher.class,HttpsServer.class,HttpContext.class)
        .addPackages(true,Pact.class.getPackage())
        .addAsServiceProvider(RemoteLoadableExtension.class,PactConsumerRemoteExtension.class);

    arquillianPactConsumer = addSunHttpServer(arquillianPactConsumer);

    final Properties properties = pactConsumerConfigurationInstance.get().asProperties();
    String configuration = toString(properties);

    arquillianPactConsumer.add(new StringAsset(configuration),"/pact-consumer-configuration.properties");

    final JavaArchive[] pactConsumerDeps = Maven.resolver()
        .resolve("au.com.dius:pact-jvm-consumer_2.11:" + getVersion())
        .withtransitivity().as(JavaArchive.class);

    final JavaArchive merge = merge(arquillianPactConsumer,pactConsumerDeps);
    return merge;
}

public static void httpserverService() throws IOException {
    HttpServerProvider provider = HttpServerProvider.provider();
    HttpServer httpserver =provider.createHttpServer(new InetSocketAddress(6666),100);//�����˿�6666,��ͬʱ�� ��100������
    httpserver.createContext("/yns3_hdfs",new MyHttpHandler()); 
    httpserver.setExecutor(null);
    httpserver.start();
    System.out.println("server started");
}

/**
 * Create a <code>HttpServer</code> instance which will bind to the
 * specified {@link java.net.InetSocketAddress} (IP address and port number)
 *
 * A maximum backlog can also be specified. This is the maximum number of
 * queued incoming connections to allow on the listening socket.
 * Queued TCP connections exceeding this limit may be rejected by the TCP implementation.
 * The HttpServer is acquired from the currently installed {@link HttpServerProvider}
 *
 * @param addr the address to listen on,if <code>null</code> then bind() must be called
 *  to set the address
 * @param backlog the socket backlog. If this value is less than or equal to zero,*          then a system default value is used.
 * @throws BindException if the server cannot bind to the requested address,*          or if the server is already bound.
 * @throws IOException
 */

public static HttpServer create (
    InetSocketAddress addr,int backlog
) throws IOException {
    HttpServerProvider provider = HttpServerProvider.provider();
    return provider.createHttpServer (addr,backlog);
}

/**
 * Create a <code>HttpServer</code> instance which will bind to the
 * specified {@link java.net.InetSocketAddress} (IP address and port number)
 *
 * A maximum backlog can also be specified. This is the maximum number of
 * queued incoming connections to allow on the listening socket.
 * Queued TCP connections exceeding this limit may be rejected by the TCP implementation.
 * The HttpServer is acquired from the currently installed {@link HttpServerProvider}
 *
 * @param addr the address to listen on,backlog);
}

/**
 * Create a <code>HttpServer</code> instance which will bind to the
 * specified {@link java.net.InetSocketAddress} (IP address and port number)
 *
 * A maximum backlog can also be specified. This is the maximum number of
 * queued incoming connections to allow on the listening socket.
 * Queued TCP connections exceeding this limit may be rejected by the TCP implementation.
 * The HttpServer is acquired from the currently installed {@link HttpServerProvider}
 *
 * @param addr the address to listen on,backlog);
}

/**
 * Create a <code>HttpServer</code> instance which will bind to the
 * specified {@link java.net.InetSocketAddress} (IP address and port number)
 *
 * A maximum backlog can also be specified. This is the maximum number of
 * queued incoming connections to allow on the listening socket.
 * Queued TCP connections exceeding this limit may be rejected by the TCP implementation.
 * The HttpServer is acquired from the currently installed {@link HttpServerProvider}
 *
 * @param addr the address to listen on,backlog);
}

/**
 * Create a <code>HttpServer</code> instance which will bind to the
 * specified {@link java.net.InetSocketAddress} (IP address and port number)
 *
 * A maximum backlog can also be specified. This is the maximum number of
 * queued incoming connections to allow on the listening socket.
 * Queued TCP connections exceeding this limit may be rejected by the TCP implementation.
 * The HttpServer is acquired from the currently installed {@link HttpServerProvider}
 *
 * @param addr the address to listen on,backlog);
}

/**
 * Create a <code>HttpServer</code> instance which will bind to the
 * specified {@link java.net.InetSocketAddress} (IP address and port number)
 *
 * A maximum backlog can also be specified. This is the maximum number of
 * queued incoming connections to allow on the listening socket.
 * Queued TCP connections exceeding this limit may be rejected by the TCP implementation.
 * The HttpServer is acquired from the currently installed {@link HttpServerProvider}
 *
 * @param addr the address to listen on,backlog);
}

/**
 * Create a <code>HttpServer</code> instance which will bind to the
 * specified {@link java.net.InetSocketAddress} (IP address and port number)
 *
 * A maximum backlog can also be specified. This is the maximum number of
 * queued incoming connections to allow on the listening socket.
 * Queued TCP connections exceeding this limit may be rejected by the TCP implementation.
 * The HttpServer is acquired from the currently installed {@link HttpServerProvider}
 *
 * @param addr the address to listen on,backlog);
}

/**
 * Create a <code>HttpServer</code> instance which will bind to the
 * specified {@link java.net.InetSocketAddress} (IP address and port number)
 *
 * A maximum backlog can also be specified. This is the maximum number of
 * queued incoming connections to allow on the listening socket.
 * Queued TCP connections exceeding this limit may be rejected by the TCP implementation.
 * The HttpServer is acquired from the currently installed {@link HttpServerProvider}
 *
 * @param addr the address to listen on,backlog);
}

/**
 * Create a <code>HttpServer</code> instance which will bind to the
 * specified {@link java.net.InetSocketAddress} (IP address and port number)
 *
 * A maximum backlog can also be specified. This is the maximum number of
 * queued incoming connections to allow on the listening socket.
 * Queued TCP connections exceeding this limit may be rejected by the TCP implementation.
 * The HttpServer is acquired from the currently installed {@link HttpServerProvider}
 *
 * @param addr the address to listen on,backlog);
}

/**
 * Create a <code>HttpServer</code> instance which will bind to the
 * specified {@link java.net.InetSocketAddress} (IP address and port number)
 *
 * A maximum backlog can also be specified. This is the maximum number of
 * queued incoming connections to allow on the listening socket.
 * Queued TCP connections exceeding this limit may be rejected by the TCP implementation.
 * The HttpServer is acquired from the currently installed {@link HttpServerProvider}
 *
 * @param addr the address to listen on,backlog);
}

/**
 * Create a <code>HttpServer</code> instance which will bind to the
 * specified {@link java.net.InetSocketAddress} (IP address and port number)
 *
 * A maximum backlog can also be specified. This is the maximum number of
 * queued incoming connections to allow on the listening socket.
 * Queued TCP connections exceeding this limit may be rejected by the TCP implementation.
 * The HttpServer is acquired from the currently installed {@link HttpServerProvider}
 *
 * @param addr the address to listen on,backlog);
}

/**
 * Create a <code>HttpServer</code> instance which will bind to the
 * specified {@link java.net.InetSocketAddress} (IP address and port number)
 *
 * A maximum backlog can also be specified. This is the maximum number of
 * queued incoming connections to allow on the listening socket.
 * Queued TCP connections exceeding this limit may be rejected by the TCP implementation.
 * The HttpServer is acquired from the currently installed {@link HttpServerProvider}
 *
 * @param addr the address to listen on,backlog);
}

/**
 * Create a <code>HttpServer</code> instance which will bind to the
 * specified {@link java.net.InetSocketAddress} (IP address and port number)
 *
 * A maximum backlog can also be specified. This is the maximum number of
 * queued incoming connections to allow on the listening socket.
 * Queued TCP connections exceeding this limit may be rejected by the TCP implementation.
 * The HttpServer is acquired from the currently installed {@link HttpServerProvider}
 *
 * @param addr the address to listen on,backlog);
}