How to use org.eclipse.jgit.transport.http

  /** {@inheritDoc} */
  @Override
  public HttpConnection create(URL url, Proxy proxy)
      throws IOException {
    return new JDKHttpConnection(url, proxy);
  }
}

/**
 * Extract a HTTP header from the response.
 *
 * @param c
 *            connection the header should be obtained from.
 * @param headerName
 *            the header name
 * @return the header value
 * @throws java.io.IOException
 *             communications error prevented obtaining the header.
 * @since 4.7
 */
public static String responseHeader(final HttpConnection c,
    final String headerName) throws IOException {
  return c.getHeaderField(headerName);
}

private boolean isSmartHttp(HttpConnection c, String service) {
  final String expType = "application/x-" + service + "-advertisement"; //$NON-NLS-1$ //$NON-NLS-2$
  final String actType = c.getContentType();
  return expType.equals(actType);
}

HttpConnection conn = connectionFactory.create(u, proxy);
conn.setInstanceFollowRedirects(false);
conn.setRequestMethod(method);
conn.setUseCaches(false);
if (acceptEncoding == AcceptEncoding.GZIP) {
  conn.setRequestProperty(HDR_ACCEPT_ENCODING, ENCODING_GZIP);
conn.setRequestProperty(HDR_PRAGMA, "no-cache"); //$NON-NLS-1$
if (UserAgent.get() != null) {
  conn.setRequestProperty(HDR_USER_AGENT, UserAgent.get());
  conn.setConnectTimeout(effTimeOut);
  conn.setReadTimeout(effTimeOut);
    conn.setRequestProperty(entry.getKey(), entry.getValue());

void openStream() throws IOException {
  conn = httpOpen(METHOD_POST, new URL(baseUrl, serviceName),
      AcceptEncoding.GZIP);
  conn.setInstanceFollowRedirects(false);
  conn.setDoOutput(true);
  conn.setRequestProperty(HDR_CONTENT_TYPE, requestType);
  conn.setRequestProperty(HDR_ACCEPT, responseType);
}

final String nonce = params.get("nonce"); //$NON-NLS-1$
final String cnonce = params.get("cnonce"); //$NON-NLS-1$
final String uri = uri(conn.getURL());
final String qop = params.get("qop"); //$NON-NLS-1$
final String method = conn.getRequestMethod();
  v.append('"');
conn.setRequestProperty(HDR_AUTHORIZATION, type.getSchemeName()
    + " " + v); //$NON-NLS-1$

void openResponse() throws IOException {
  final int status = HttpSupport.response(conn);
  if (status != HttpConnection.HTTP_OK) {
    throw new TransportException(uri, status + " " //$NON-NLS-1$
        + conn.getResponseMessage());
  }
  final String contentType = conn.getContentType();
  if (!responseType.equals(contentType)) {
    conn.getInputStream().close();
    throw wrongContentType(responseType, contentType);
  }
}

/**
 * Get the HTTP response code from the request.
 * <p>
 * Roughly the same as <code>c.getResponseCode()</code> but the
 * ConnectException is translated to be more understandable.
 *
 * @param c
 *            connection the code should be obtained from.
 * @return r HTTP status code, usually 200 to indicate success. See
 *         {@link org.eclipse.jgit.transport.http.HttpConnection} for other
 *         defined constants.
 * @throws java.io.IOException
 *             communications error prevented obtaining the response code.
 * @since 3.3
 */
public static int response(HttpConnection c) throws IOException {
  try {
    return c.getResponseCode();
  } catch (ConnectException ce) {
    final URL url = c.getURL();
    final String host = (url == null) ? "<null>" : url.getHost(); //$NON-NLS-1$
    // The standard J2SE error message is not very useful.
    //
    if ("Connection timed out: connect".equals(ce.getMessage())) //$NON-NLS-1$
      throw new ConnectException(MessageFormat.format(JGitText.get().connectionTimeOut, host));
    throw new ConnectException(ce.getMessage() + " " + host); //$NON-NLS-1$
  }
}

  @Override
  protected OutputStream overflow() throws IOException {
    openStream();
    conn.setChunkedStreamingMode(0);
    return conn.getOutputStream();
  }
}

/**
 * Disable SSL and hostname verification for given HTTP connection
 *
 * @param conn
 *            a {@link org.eclipse.jgit.transport.http.HttpConnection}
 *            object.
 * @throws java.io.IOException
 * @since 4.3
 */
public static void disableSslVerify(HttpConnection conn)
    throws IOException {
  final TrustManager[] trustAllCerts = new TrustManager[] {
      new DummyX509TrustManager() };
  try {
    conn.configure(null, trustAllCerts, null);
    conn.setHostnameVerifier(new DummyHostnameVerifier());
  } catch (KeyManagementException e) {
    throw new IOException(e.getMessage());
  } catch (NoSuchAlgorithmException e) {
    throw new IOException(e.getMessage());
  }
}

  @Override
  void configureRequest(HttpConnection conn) throws IOException {
    GSSManager gssManager = GSS_MANAGER_FACTORY.newInstance(conn
        .getURL());
    String host = conn.getURL().getHost();
    String peerName = "HTTP@" + host.toLowerCase(Locale.ROOT); //$NON-NLS-1$
    try {
      GSSName gssName = gssManager.createName(peerName,
          GSSName.NT_HOSTBASED_SERVICE);
      GSSContext context = gssManager.createContext(gssName, OID,
          null, GSSContext.DEFAULT_LIFETIME);
      // Respect delegation policy in HTTP/SPNEGO.
      context.requestCredDeleg(true);
      byte[] token = context.initSecContext(prevToken, 0,
          prevToken.length);
      conn.setRequestProperty(HDR_AUTHORIZATION, getType().getSchemeName()
          + " " + Base64.encodeBytes(token)); //$NON-NLS-1$
    } catch (GSSException e) {
      throw new IOException(e);
    }
  }
}

FileStream open(String path, AcceptEncoding acceptEncoding)
    throws IOException {
  final URL base = httpObjectsUrl;
  final URL u = new URL(base, path);
  final HttpConnection c = httpOpen(METHOD_GET, u, acceptEncoding);
  switch (HttpSupport.response(c)) {
  case HttpConnection.HTTP_OK:
    final InputStream in = openInputStream(c);
    // If content is being gzipped and then transferred, the content
    // length in the header is the zipped content length, not the
    // actual content length.
    if (!isGzipContent(c)) {
      final int len = c.getContentLength();
      return new FileStream(in, len);
    }
    return new FileStream(in);
  case HttpConnection.HTTP_NOT_FOUND:
    throw new FileNotFoundException(u.toString());
  default:
    throw new IOException(u.toString() + ": " //$NON-NLS-1$
        + HttpSupport.response(c) + " " //$NON-NLS-1$
        + c.getResponseMessage());
  }
}

final InputStream openInputStream(HttpConnection conn)
    throws IOException {
  InputStream input = conn.getInputStream();
  if (isGzipContent(conn))
    input = new GZIPInputStream(input);
  return input;
}

  @Override
  void configureRequest(HttpConnection conn) throws IOException {
    String ident = user + ":" + pass; //$NON-NLS-1$
    String enc = Base64.encodeBytes(ident.getBytes(UTF_8));
    conn.setRequestProperty(HDR_AUTHORIZATION, type.getSchemeName()
        + " " + enc); //$NON-NLS-1$
  }
}

final Map<String, List<String>> headers = conn.getHeaderFields();
HttpAuthMethod authentication = Type.NONE.method(EMPTY_STRING);

@Override
public List<String> getHeaderFields(@NonNull String name) {
  Map<String, List<String>> m = wrappedUrlConnection.getHeaderFields();
  List<String> fields = mapValuesToListIgnoreCase(name, m);
  return fields;
}

private boolean isGzipContent(HttpConnection c) {
  return ENCODING_GZIP.equals(c.getHeaderField(HDR_CONTENT_ENCODING))
      || ENCODING_X_GZIP.equals(c.getHeaderField(HDR_CONTENT_ENCODING));
}

/** {@inheritDoc} */
@Override
public HttpConnection create(URL url) throws IOException {
  return new JDKHttpConnection(url);
}

private PushConnection smartPush(String service, HttpConnection c,
    InputStream in) throws IOException, TransportException {
  readSmartHeaders(in, service);
  SmartHttpPushConnection p = new SmartHttpPushConnection(in);
  p.setPeerUserAgent(c.getHeaderField(HttpSupport.HDR_SERVER));
  return p;
}

@SuppressWarnings("resource") // Closed by caller
private FetchConnection getConnection(HttpConnection c, InputStream in,
    String service) throws IOException {
  BaseConnection f;
  if (isSmartHttp(c, service)) {
    readSmartHeaders(in, service);
    f = new SmartHttpFetchConnection(in);
  } else {
    // Assume this server doesn't support smart HTTP fetch
    // and fall back on dumb object walking.
    f = newDumbConnection(in);
  }
  f.setPeerUserAgent(c.getHeaderField(HttpSupport.HDR_SERVER));
  return (FetchConnection) f;
}