HTTP/2 supports queries multiplexing, headers compression, priority and more intelligent packet streaming management. This results in reduced latency and accelerates content download on modern web pages.

[More details here.][1]


  [1]: https://daniel.haxx.se/http2/

HTTP 2.0 is a **binary** protocol that multiplexes numerous streams going over a single (normally TLS-encrypted) TCP connection.

The contents of each stream are HTTP 1.1 requests and responses, just encoded and packed up differently. HTTP2 adds a number of features to manage the streams, but leaves old semantics untouched.

I&#39;m using Typescript with React. I&#39;m having trouble understanding how to use refs so as to get static typing and intellisense with respect to the react nodes referenced by the refs. My code is as follows.

    import * as React from &#39;react&#39;;

    interface AppState {
    	count: number;
    }
    
    interface AppProps {
    	steps: number;
    }
    
    interface AppRefs {
    	stepInput: HTMLInputElement;
    }

    export default class TestApp extends React.Component&lt;AppProps, AppState&gt; {
	
	constructor(props: AppProps) {
		super(props);
		this.state = {
			count: 0
		};
	}
	
	incrementCounter() {
		this.setState({count: this.state.count + 1});
	}
	
	render() {
		return (
			&lt;div&gt;
				&lt;h1&gt;Hello World&lt;/h1&gt;
				&lt;input type=&quot;text&quot; ref=&quot;stepInput&quot; /&gt;
				&lt;button onClick={() =&gt; this.incrementCounter()}&gt;Increment&lt;/button&gt;
				Count : {this.state.count}
			&lt;/div&gt;
		);
	}}

How to use refs in React with Typescript

I have a `LocalDate` variable called `date`, when I print it displays 1988-05-05 I need to convert this to be printed as 05.May 1988. How to do this?

How to format LocalDate to string?

&gt; HTTP/1.1 has served the Web well for more than fifteen years, but its
&gt; age is starting to show.

Can anybody explain what is the **main difference** between HTTP 1.1 and 2.0?

Is there any change in the transport protocol?


What is the difference between HTTP 1.1 and HTTP 2.0?

> HTTP/1.1 has served the Web well for more than fifteen years, but its
> age is starting to show.
Can anybody explain what is the main difference between HTTP 1.1 and 2.0?
Is there any change in the transport protocol?

Let&#39;s assume there are two resources `Binder` and `Doc` with association relationship meaning that the `Doc` and `Binder` stand on their own. `Doc` might or might not belong to `Binder` and `Binder` might be empty.

If I want to design a REST API that allows a user to send a collection of `Doc`s, **IN A SINGLE REQUEST**, like the following:

    {
      &quot;docs&quot;: [
        {&quot;doc_number&quot;: 1, &quot;binder&quot;: 1}, 
        {&quot;doc_number&quot;: 5, &quot;binder&quot;: 8},
        {&quot;doc_number&quot;: 6, &quot;binder&quot;: 3}
      ]
    }

And for each doc in the `docs`, 

 - If the `doc` exists then assign it to `Binder`
 - If the `doc` doesn&#39;t exist, create it and then assign it

I&#39;m really confused as to how this should be implemented: 

 - What HTTP method to use? 
 - What response code must be returned? 
 - Is this even qualified for REST?
 - How would the URI look like? `/binders/docs`?
 - Handling bulk request, what if a few items raise an error but the other go through. What response code must be returned? Should the bulk operation be atomic?

REST API - Bulk Create or Update in single request

Is it possible currently to get node.js HTTP/2 (HTTP 2.0) server? And http 2.0 version of express.js?

node.js server and HTTP/2 (2.0) with express.js

Performing millions of HTTP requests with different Java libraries gives me threads hanged on:

`java.net.SocketInputStream.socketRead0()`

Which is `native` function.

I tried to set up Apche Http Client and `RequestConfig` to have timeouts on  (I hope) everythig that is possible but still, **I have (probably infinite) hangs on `socketRead0`. How to get rid of them?**

Hung ratio is about ~1 per 10000 requests (to 10000 different hosts) and it can last probably forever (I&#39;ve confirmed thread hung as still valid after 10 hours).

JDK 1.8 on Windows 7.

My `HttpClient` factory:

    SocketConfig socketConfig = SocketConfig.custom()
                .setSoKeepAlive(false)
                .setSoLinger(1)
                .setSoReuseAddress(true)
                .setSoTimeout(5000)
                .setTcpNoDelay(true).build();

        HttpClientBuilder builder = HttpClientBuilder.create();
        builder.disableAutomaticRetries();
        builder.disableContentCompression();
        builder.disableCookieManagement();
        builder.disableRedirectHandling();
        builder.setConnectionReuseStrategy(new NoConnectionReuseStrategy());
        builder.setDefaultSocketConfig(socketConfig);

        return HttpClientBuilder.create().build();

My `RequestConfig` factory:

        HttpGet request = new HttpGet(url);

        RequestConfig config = RequestConfig.custom()
                .setCircularRedirectsAllowed(false)
                .setConnectionRequestTimeout(8000)
                .setConnectTimeout(4000)
                .setMaxRedirects(1)
                .setRedirectsEnabled(true)
                .setSocketTimeout(5000)
                .setStaleConnectionCheckEnabled(true).build();
        request.setConfig(config);

        return new HttpGet(url);

[OpenJDK `socketRead0` source][1]

Note: Actually I have some &quot;trick&quot; - I can schedule `.getConnectionManager().shutdown()` in other `Thread` with cancellation of `Future` if request finished properly, but it is depracated and also it kills whole `HttpClient`, not only that single request.


  [1]: http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/windows/native/java/net/SocketInputStream.c

How to prevent hangs on SocketInputStream.socketRead0 in Java?

Anybody aware of default timeout value of [RestSharp][1] RestClient ?


  [1]: https://github.com/restsharp/

What is default timeout value of RestSharp RestClient?

I&#39;m wondering if its possible to programmatically discover all the endpoints of a particular API. 

So for example if I GET this URL with a browser or curl:
https://api.twitter.com/1.1/

I might get something like this as a JSON response:

```
&quot;TwitterAPI&quot;:{
	&quot;version&quot; : 1.1,
	&quot;GET&quot; : {
		&quot;search/&quot; : [&quot;users&quot;, &quot;trending&quot;],
		&quot;users/&quot; : [&quot;id&quot;, &quot;handle&quot;]
	}
}
```

Of course Twitter could choose to publish or not publish this format. So as a side question, are there any libraries for Java or JavaScript that will automatically map and publish the API routes you created in your controllers?  

Is there a way to discover all endpoints of a REST API?

I am reading the Flask documentation.  I was told that with `app.run(host=&#39;0.0.0.0&#39;)`, I could make the server publicly available. 

What does it mean ? How can I visit the server in another computer (just `localhost:5000` in my own computer) ?


What does &quot;app.run(host=&#39;0.0.0.0&#39;) &quot; mean in Flask

I want to send a `PING` to Redis to check if the connection is working, now I could just install `redis-cli`, but I don&#39;t want to and `curl` is already there. So how can I abuse `curl` to do that? Basically I need to turn off what&#39;s send here:

    &gt; GET / HTTP/1.1
    &gt; User-Agent: curl/7.22.0 (x86_64-pc-linux-gnu) libcurl/7.22.0 OpenSSL/1.0.1 zlib/1.2.3.4 libidn/1.23 librtmp/2.3
    &gt; Host: localhost:6379
    &gt; Accept: */*
    &gt; 
    -ERR wrong number of arguments for &#39;get&#39; command
    -ERR unknown command &#39;User-Agent:&#39;
    -ERR unknown command &#39;Host:&#39;
    -ERR unknown command &#39;Accept:&#39;

I was able to get rid of the `User-Agent` altogether by adding `-A &quot;&quot;`, but I can&#39;t find anything else for the rest. Any idea how I can do that?

Abuse cURL to communicate with Redis

How do you get `lsof` to produce numeric port information instead of attempting to resolve the port to service name?

For example, I want ``TCP *:http (LISTEN)`` to give me ``TCP *:80 (LISTEN)`` in-fact if at all possible I never want to see another service name in ``lsof`` print-out ever again.  So if there is a way to make numeric ports the default I would like to understand how to do that as well.

lsof print numeric ports

With the release of TCP load balancing for the Nginx community version, I would like to mix OpenVPN and SSL pass-through data. The only way for Nginx to know how to route the traffic is via their domain name.

     vpn1.app.com ─┬─► nginx at 10.0.0.1 ─┬─► vpn1  at 10.0.0.3
     vpn2.app.com ─┤                      ├─► vpn2  at 10.0.0.4
    https.app.com ─┘                      └─► https at 10.0.0.5

I have taken a look at the [TCP guides][1] and the [module documentation][2], but it doesn&#39;t seem well referenced. If anyone can point me to the right direction, i&#39;d be grateful.

Related question on ServerFault: [Can a Reverse Proxy use SNI with SSL pass through?][3]


  [1]: https://www.nginx.com/resources/admin-guide/tcp-load-balancing/
  [2]: http://nginx.org/en/docs/stream/ngx_stream_core_module.html?_ga=1.74120594.1237357975.1452565611
  [3]: https://serverfault.com/questions/625362/can-a-reverse-proxy-use-sni-with-ssl-pass-through

Nginx TCP forwarding based on hostname

I have a Windows application that needs to use ports `50005` and `50006` but it is being blocked.

I see the following when I run `netsh int ip show excludedportrange protocol=tcp`:

    Protocol tcp Port Exclusion Ranges
    
    Start Port    End Port
    ----------    --------
    5357        5357
    49709       49808
    49809       49908
    49909       50008
    50009       50108
    50109       50208
    50280       50379
    
    * - Administered port exclusions.

So something on my machine is reserving ports `49909` to `50008`, which is presumably what is causing my application to fail. I&#39;ve tried deleting this `excludedportrange` with the following command:

    netsh int ip delete excludedportrange protocol=tcp numberofports=100 startport=49909

But I see an error `Access is denied.`, which makes me think that whatever is reserving this ports is actively running, but I have no idea what that could be. 

What&#39;s also weird is that after running that command, even though I saw an error, if I reboot the `excludedportrange` will be different.

As a sanity check I&#39;ve also run `resmon.exe` and confirmed that there is nothing running on ports `50005` and `50006`.

How can I tell what is adding the `excludedportrange`?

**EDIT:** I&#39;ve narrowed this down to Hyper-V. If I disable Hyper-V then those ports are not excluded.

How to see what is reserving ephemeral port ranges on Windows?

I have installed the Windows 10 Insider Program. Everything works, except Apache. When I try to start it, it says that port 80 is blocked. Is there a way to unblock it or **tell Apache to use another port instead?**

I was using Windows 7 before. I had trouble with port 80 with skype, but i have disabled it.

Apache Server (xampp) doesn&#39;t run on Windows 10 (Port 80)

I am using nginx and node server to serve update requests. I get a gateway timeout when I request an update on large data. I saw this error from the nginx error logs :

&gt; 2016/04/07 00:46:04 [error] 28599#0: *1 upstream prematurely closed
&gt; connection while reading response header from upstream, client:
&gt; 10.0.2.77, server: gis.oneconcern.com, request: &quot;GET /update_mbtiles/atlas19891018000415 HTTP/1.1&quot;, upstream:
&gt; &quot;http://127.0.0.1:7777/update_mbtiles/atlas19891018000415&quot;, host:
&gt; &quot;gis.oneconcern.com&quot;

I googled for the error and tried everything I could, but I still get the error. 

My nginx conf has these proxy settings:
   

        ##
        # Proxy settings
        ##

        proxy_connect_timeout 1000;
        proxy_send_timeout 1000;
        proxy_read_timeout 1000;
        send_timeout 1000;

This is how my server is configured 

    server {
    listen 80;

    server_name gis.oneconcern.com;
    access_log /home/ubuntu/Tilelive-Server/logs/nginx_access.log;
    error_log /home/ubuntu/Tilelive-Server/logs/nginx_error.log;

    large_client_header_buffers 8 32k;
    location / {
        proxy_pass http://127.0.0.1:7777;
        proxy_redirect off;

        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection &#39;upgrade&#39;;
        proxy_set_header Host $http_host;
        proxy_cache_bypass $http_upgrade;
    }

    location /faults {
        proxy_pass http://127.0.0.1:8888;
        proxy_http_version 1.1;
        proxy_buffers 8 64k;
        proxy_buffer_size 128k;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection &#39;upgrade&#39;;
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

I am using a nodejs backend to serve the requests on an aws server. The gateway error shows up only when the update takes a long time (about 3-4 minutes). I do not get any error for smaller updates. Any help will be highly appreciated. 

Node js code :

    app.get(&quot;/update_mbtiles/:earthquake&quot;, function(req, res){
    var earthquake = req.params.earthquake
    var command = spawn(__dirname + &#39;/update_mbtiles.sh&#39;, [ earthquake, pg_details ]);
    //var output  = [];

    command.stdout.on(&#39;data&#39;, function(chunk) {
    //    logger.info(chunk.toString());
    //     output.push(chunk.toString());
    });

    command.stderr.on(&#39;data&#39;, function(chunk) {
      //  logger.error(chunk.toString());
     //   output.push(chunk.toString());
    });

    command.on(&#39;close&#39;, function(code) {
        if (code === 0) {
            logger.info(&quot;updating mbtiles successful for &quot; + earthquake);
            tilelive_reload_and_switch_source(earthquake);
            res.send(&quot;Completed updating!&quot;);
        }
        else {
            logger.error(&quot;Error occured while updating &quot; + earthquake);
            res.status(500);
            res.send(&quot;Error occured while updating &quot; + earthquake);
        }
    });
    });

    function tilelive_reload_and_switch_source(earthquake_unique_id) {
    tilelive.load(&#39;mbtiles:///&#39;+__dirname+&#39;/mbtiles/tipp_out_&#39;+ earthquake_unique_id + &#39;.mbtiles&#39;, function(err, source) {
        if (err) {
            logger.error(err.message);
            throw err;
        }
        sources.set(earthquake_unique_id, source); 
        logger.info(&#39;Updated source! New tiles!&#39;);
    });
    }

Thank you.


Nginx upstream prematurely closed connection while reading response header from upstream, for large requests

I have been studying Node.js recently and came across some material on writing simple Node.js based servers. For example, the following.

    var express = require(&quot;express&quot;),
    http = require(&quot;http&quot;), app;

    // Create our Express-powered HTTP server
    // and have it listen on port 3000
    app = express();
    http.createServer(app).listen(3000);

    // set up our routes
    app.get(&quot;/hello&quot;, function (req, res) {
        res.send(&quot;Hello World!&quot;);
    });

    app.get(&quot;/goodbye&quot;, function (req, res) {
        res.send(&quot;Goodbye World!&quot;);
    });


Now, although I seem to understand what&#39;s going on in the code, I am slightly confused by the terminology. When I hear the term server, I think about stuff like Apache or Nginx. I am used to thinking about them as being like a container that can hold my web applications. How does Node.js server differ from Nginx/Apache server? Isn&#39;t it true that a Node.js based server (i.e. code) can still be placed within something like Nginx to run? So why are both called &quot;servers&quot;?

How does a Node.js &quot;server&quot; compare with Nginx or Apache servers?

Occasionally when troubleshooting bugs in production, it would be convenient to be able to hit our production REST server from my local dev environment. But i&#39;m concerned that adding localhost to allowed origins would be a security risk. Searches have yielded conflicting information. Are my concerns valid? Why or why not?

CORS - localhost as allowed origin in production

I know from this question and answer on Super User [Site running on localhost on desktop is unreachable on android device][1] _(**PS:** this question continues on the question in the link)_ that the command `ng serve` opens a bad configured webserver.

The question is how could I run my site on an Android device without deploying my site. I&#39;ll try to run the site on this url `http://192.168.0.168:4200` using Angular-CLI.

 [1]:https://superuser.com/questions/1193168/site-running-on-localhost-on-desktop-is-unreachable-on-android-device/

How to run my Angular site on mobile device that is running localhost on my windows desktop

Could someone please explain multiplexing in relation to HTTP/2 and how it works?

What does multiplexing mean in HTTP/2

I have a node.js server running behind an nginx proxy. node.js is running an HTTP 1.1 (no SSL) server on port 3000. Both are running on the same server.

I recently set up nginx to use HTTP2 with SSL (h2). It seems that HTTP2 is indeed enabled and working.

However, I want to know whether the fact that the proxy connection (nginx &lt;--&gt; node.js) is using HTTP 1.1 affects performance. That is, am I missing the HTTP2 benefits in terms of speed because my internal connection is HTTP 1.1?

HTTP2 with node.js behind nginx proxy

The goal is to introduce a transport and application layer protocol that is better in its **latency** and **network throughput**. Currently, the application uses **REST** with **HTTP/1.1** and we experience a high latency. I need to resolve this latency problem and I am open to use either **gRPC(HTTP/2)** or **REST/HTTP2**.

**HTTP/2:**

 1. Multiplexed
 2. Single TCP Connection
 3. Binary instead of textual
 4. Header compression
 5. Server Push

I am aware of all the above advantages. **Question No. 1:** If I use **REST with HTTP/2**, I am sure, I will get a significant performance improvement when compared to **REST with HTTP/1.1**, but how does this compare with **gRPC(HTTP/2)**?

I am also aware that gRPC uses proto buffer, which is the best **binary serialization** technique for transmission of structured data on the wire. Proto buffer also helps in developing an language agnostic approach. I agree with that and I can implement the same feature in REST using graphQL. But my concern is over serialization: **Question No. 2:** When **HTTP/2** implements this **binary feature**, does using proto buffer give an added advantage on top of HTTP/2? 

**Question No. 3:** In terms of **streaming, bi-directional use-cases**, how does gRPC(HTTP/2) compare with (REST and HTTP/2)?

There are so many **blogs/videos** out in the internet that compares gRPC(HTTP/2) with (REST and HTTP/1.1) like [this][1]. As stated earlier, I would like to know the differences, benefits on comparing GRPC(HTTP/2) and (REST with HTTP/2).


  [1]: https://husobee.github.io/golang/rest/grpc/2016/05/28/golang-rest-v-grpc.html

Is gRPC(HTTP/2) faster than REST with HTTP/2?

I want to develop a client-server application in a bi-directional streaming manner.

what is more suitable technology for this, grpc or websocket?

Content Type	Original Author	Original Content on Stackoverflow
Question	user1968030	View Question on Stackoverflow
Solution 1 - Http	84RR1573R	View Answer on Stackoverflow
Solution 2 - Http	phihag	View Answer on Stackoverflow

What is the difference between HTTP 1.1 and HTTP 2.0?

Http Problem Overview

Http Solutions

Solution 1 - Http

Solution 2 - Http

How to format LocalDate to string?

How to use refs in React with Typescript

Attributions