Comment faire pour ping le port du serveur http2 pour la vivacité (serveur grpc)?

Question

J'essaye de cingler un port de serveur de HTTP de grpc pour la vivacité. Dans Http1.1 nous utiliserions url.openConnection et vérifierions le code d'état de réponse.

Quel est l'équivalent dans http2?

Le code ci-dessous ne semble pas être erroné mais je ne sais pas exactement comment l'utiliser pour vérifier si la requête a réussi?

import org.apache.commons.io.IOUtils; 
import org.eclipse.jetty.http.HttpFields; 
import org.eclipse.jetty.http.HttpURI; 
import org.eclipse.jetty.http.HttpVersion; 
import org.eclipse.jetty.http.MetaData; 
import org.eclipse.jetty.http2.api.Session; 
import org.eclipse.jetty.http2.api.Stream; 
import org.eclipse.jetty.http2.api.server.ServerSessionListener; 
import org.eclipse.jetty.http2.client.HTTP2Client; 
import org.eclipse.jetty.http2.frames.DataFrame; 
import org.eclipse.jetty.http2.frames.HeadersFrame; 
import org.eclipse.jetty.util.Callback; 
import org.eclipse.jetty.util.FuturePromise; 
import org.eclipse.jetty.util.Jetty; 
import org.eclipse.jetty.util.ssl.SslContextFactory; 

import javax.net.ssl.HttpsURLConnection; 
import java.io.IOException; 
import java.net.HttpURLConnection; 
import java.net.InetSocketAddress; 
import java.net.Socket; 
import java.net.URL; 
import java.util.concurrent.TimeUnit; 

public class HeartbeatCheckHttp2 { 
    public static void main(String [] args) throws Exception { 
     for (int i=0; i<50000; ++i) { 
      Thread.sleep(400L); 

      HTTP2Client client = new HTTP2Client(); 
      client.start(); 

      // Connect to host. 
      String host = "localhost"; 
      int port = 50000; 

      FuturePromise<Session> sessionPromise = new FuturePromise<>(); 
      client.connect(new InetSocketAddress(host, port), new ServerSessionListener.Adapter(), sessionPromise); 


      // Obtain the client Session object. 
      Session session = sessionPromise.get(5, TimeUnit.SECONDS); 

      // Prepare the HTTP request headers. 
      HttpFields requestFields = new HttpFields(); 
      requestFields.put("User-Agent", client.getClass().getName() + "/" + Jetty.VERSION); 
      requestFields.put("Content-Type", "application/grpc"); 
      // Prepare the HTTP request object. 
      MetaData.Request request = new MetaData.Request("POST", new HttpURI("http://" + host + ":" + port + "/"), HttpVersion.HTTP_2, requestFields); 
      // Create the HTTP/2 HEADERS frame representing the HTTP request. 
      HeadersFrame headersFrame = new HeadersFrame(request, null, true); 

      // Prepare the listener to receive the HTTP response frames. 
      Stream.Listener responseListener = new Stream.Listener.Adapter() 
      { 
       @Override 
       public void onData(Stream stream, DataFrame frame, Callback callback) 
       { 
        byte[] bytes = new byte[frame.getData().remaining()]; 
        frame.getData().get(bytes); 
        callback.succeeded(); 
       } 
      }; 

      session.newStream(headersFrame, new FuturePromise<>(), responseListener); 
      session.newStream(headersFrame, new FuturePromise<>(), responseListener); 
      session.newStream(headersFrame, new FuturePromise<>(), responseListener); 

      Thread.sleep(TimeUnit.SECONDS.toMillis(20)); 


      client.stop(); 
     } 
    } 
} 

Je peux utiliser SocketAddress ping la liveness Tcp, mais je veux faire un appel HTTP2 réel pour faire le contrôle liveness.

Answer 1

Le protocole HTTP/2 comporte des trames de signal de présence intégrées qui peuvent être utilisées pour "envoyer un ping" à l'autre homologue afin de déterminer son niveau de vie.

HTTP2Client client = new HTTP2Client(); 
client.start(); 

FuturePromise<Session> sessionPromise = new FuturePromise<>(); 
client.connect(new InetSocketAddress(host, port), new ServerSessionListener.Adapter() { 
    @Override 
    public void onPing(Session session, PingFrame frame) { 
     // The other peer replies to our pings. 
    } 
}, sessionPromise); 
Session session = sessionPromise.get(5, TimeUnit.SECONDS); 

session.ping(new PingFrame(System.nanoTime(), false), Callback.NOOP); 

Ceci étant dit sur les si vous voulez vérifier l'état de réponse d'une requête HTTP installations de ping intégrées, vous devez mettre en œuvre onHeaders():

Stream.Listener responseListener = new Stream.Listener.Adapter() { 
    @Override 
    public void onHeaders(Stream stream, HeadersFrame frame) { 
     MetaData metaData = frame.getMetaData(); 
     if (metaData.isResponse()) { 
      MetaData.Response response = (MetaData.Response)metaData; 
      int status = response.getStatus(); 
      ... 
     } 
    } 

    @Override 
    public void onData(Stream stream, DataFrame frame, Callback callback) { 
     ... 
    } 
}; 

Voici comment vous le feriez avec un serveur qui parle HTTP via le tramage HTTP/2.

Avec gRPC, les choses peuvent être différentes, car le gRPC protocol est transporté par des trames HTTP/2, mais ce n'est pas HTTP.