docs: @Override
      public void pushNewRequest(Http2PushBuilder pushBuilder) {
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
              Tr.entry(tc, "HTTPRequestMessageImpl.pushNewRequest(): pushNewRequest() started " + this);
          }
  
          //Test to see if this is an HTTP/2 link, and that the client endpoint wants to accept push_promise frames
          if (!isPushSupported()) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
                  Tr.exit(tc, "HTTPRequestMessageImpl.pushNewRequest(): Push_promise is not client supported, this is not an HTTP/2 connection, or the connection is closing.");
              }
              return;
          }
  
          // Find the existing H2 connection and stream so we can use them to send the
          // push_promise frame to the client.
          HttpInboundServiceContext isc = (HttpInboundServiceContext) getServiceContext();
          HttpInboundLink link = ((HttpInboundServiceContextImpl) isc).getLink();
  
          H2HeaderTable h2WriteTable = ((H2HttpInboundLinkWrap) link).muxLink.getWriteTable();
  
          // Get the request headers from the pushBuilder.
          // Create a headers block to be use for the push_promise and headers frames
          ByteArrayOutputStream ppStream = new ByteArrayOutputStream();
  
          // path is equal to uri + queryString
          String pbPath = null;
          if (pushBuilder.getPathQueryString() != null) {
              pbPath = pushBuilder.getURI() + pushBuilder.getPathQueryString();
          } else {
              pbPath = pushBuilder.getURI();
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
              Tr.debug(tc, "HTTPRequestMessageImpl pbPath = " + pbPath);
          }
  
          try {
              // If all is well, start encoding, first the method
              ppStream.write(H2Headers.encodeHeader(h2WriteTable, HpackConstants.METHOD, pushBuilder.getMethod(), LiteralIndexType.NOINDEXING));
  
              // Encode the scheme
              String scheme = new String("https");
              if (!isc.isSecure()) {
                  scheme = new String("http");
              }
              ppStream.write(H2Headers.encodeHeader(h2WriteTable, HpackConstants.SCHEME, scheme, LiteralIndexType.NOINDEXING));
  
              // Encode authority
              // If the :authority header was sent in the request, get the information from there
              // If it was not, use getTargetHost and and getTargetPort to create it
              // If it's still null, we have to bail, since it's a required header in a push_promise frame
              String auth = ((H2HttpInboundLinkWrap) link).muxLink.getAuthority();
              if (null == auth) {
                  auth = getTargetHost();
                  if (null != auth) {
                      if (0 <= getTargetPort()) {
                          auth = auth + ":" + Integer.toString(getTargetPort());
                      }
                  } else {
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.exit(tc, "HTTPRequestMessageImpl: Cannot find hostname for required :authority pseudo header");
                      }
                      return;
                  }
              }
  
              ppStream.write(H2Headers.encodeHeader(h2WriteTable, HpackConstants.AUTHORITY, auth, LiteralIndexType.NOINDEXING));
  
              ppStream.write(H2Headers.encodeHeader(h2WriteTable, HpackConstants.PATH, pbPath, LiteralIndexType.NOINDEXING));
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.debug(tc, "HTTPRequestMessageImpl: Method is GET,  scheme is " + scheme + ", auth is " + auth);
              }
  
              // Encode headers, if any are present
              Set<HeaderField> headerSet = pushBuilder.getHeaders();
              if (headerSet != null) {
                  Iterator<HeaderField> hsit = headerSet.iterator();
                  HeaderField hf = null;
                  while (hsit.hasNext()) {
                      hf = hsit.next();
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(tc, "HTTPRequestMessageImpl.getHeaders() " + hf.getName() + " " + hf.asString());
                      }
                      ppStream.write(H2Headers.encodeHeader(h2WriteTable, hf.getName(), hf.asString(), LiteralIndexType.NOINDEXING));
  
                  }
              } else {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                      Tr.debug(tc, "HTTPRequestMessageImpl.getHeaders() no headers");
                  }
              }
  
          }
          // Either IOException from write, or CompressionException from encodeHeader
          catch (IOException ioe) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.exit(tc, "HTTPRequestMessageImpl.pushNewRequest(): The attempt to write an HTTP/2 Push Promise frame resulted in an IOException. Exception {0}" + ioe);
              }
              return;
          } catch (CompressionException ce) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
                  Tr.exit(tc, "HTTPRequestMessageImpl.pushNewRequest(): The attempt to encode an HTTP/2 Push Promise frame resulted in a CompressionException. Exception {0}" + ce);
              }
              return;
          }
  
          // Get the next available even numbered promised stream id
          int promisedStreamId = ((H2HttpInboundLinkWrap) link).muxLink.getNextPromisedStreamId();
          // createNewInboundLink creates new:
          // - H2VirtualConnectionImpl
          // - H2HttpInboundLinkWrap
          // - H2StreamProcessor in Idle state
          // It puts the new SP into the SPTable
  
          H2StreamProcessor promisedSP = ((H2HttpInboundLinkWrap) link).muxLink.createNewInboundLink(promisedStreamId);
          if (promisedSP == null) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
                  Tr.exit(tc, "pushNewRequest exit; cannot create new push stream -"
                              + " the max number of concurrent streams has already been reached on link: " + link);
              }
              return;
          }
          ((H2HttpInboundLinkWrap) link).setPushPromise(true);
          // Update the promised stream state to Localreserved
          promisedSP.initializePromisedStream();
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
              Tr.debug(tc, "HTTPRequestMessageImpl.pushNewRequest(): push_promise stream-id is " + promisedStreamId);
          }
  
          // Get the existing stream id
          int streamId = ((H2HttpInboundLinkWrap) link).getStreamId();
  
          // Create the push_promise frame to send to the client
          FramePushPromise pushPromiseFrame = new FramePushPromise(streamId, ppStream.toByteArray(), promisedStreamId, 0, true, false, false);
  
          // Create a headers frame to send to wc, as if it had come in from the client
          FramePPHeaders headersFrame = new FramePPHeaders(streamId, ppStream.toByteArray());
  
          // Get the existing stream processor and send the push_promise frame to the client
          H2StreamProcessor existingSP = ((H2HttpInboundLinkWrap) link).muxLink.getStreamProcessor(streamId);
          if (existingSP != null) {
              try {
                  existingSP.processNextFrame(pushPromiseFrame, Constants.Direction.WRITING_OUT);
              } catch (Http2Exception e) {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
                      Tr.exit(tc, "HTTPRequestMessageImpl.pushNewRequest(): processNextFrame threw a ProtocolException " + e);
                  }
                  return;
              }
          } else {
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
                  Tr.exit(tc, "HTTPRequestMessageImpl.pushNewRequest(): The client connection using stream-id " + streamId + " has been closed, push() was ignored..");
              }
              return;
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
              Tr.debug(tc, "HTTPRequestMessageImpl.pushNewRequest(): Push promise frame sent on stream-id " + streamId);
          }
  
          // Send the headers frame to wc
          promisedSP.sendRequestToWc(headersFrame);
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
              Tr.exit(tc, "HTTPRequestMessageImpl.pushNewRequest(): pushNewRequest() exit " + this);
          }
  
      }