source.dussan.org Git - sonarqube.git/blob

   1 /*
   2  * SonarQube
   3  * Copyright (C) 2009-2021 SonarSource SA
   4  * mailto:info AT sonarsource DOT com
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 3 of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20 package org.sonar.alm.client.github;
  21
  22 import java.io.IOException;
  23 import java.net.MalformedURLException;
  24 import java.net.URL;
  25 import java.util.Optional;
  26 import java.util.regex.Matcher;
  27 import java.util.regex.Pattern;
  28 import javax.annotation.CheckForNull;
  29 import javax.annotation.Nullable;
  30 import okhttp3.FormBody;
  31 import okhttp3.MediaType;
  32 import okhttp3.OkHttpClient;
  33 import okhttp3.Request;
  34 import okhttp3.RequestBody;
  35 import okhttp3.ResponseBody;
  36 import org.sonar.alm.client.TimeoutConfiguration;
  37 import org.sonar.alm.client.github.security.AccessToken;
  38 import org.sonar.api.utils.log.Logger;
  39 import org.sonar.api.utils.log.Loggers;
  40 import org.sonarqube.ws.client.OkHttpClientBuilder;
  41
  42 import static com.google.common.base.Preconditions.checkArgument;
  43 import static java.net.HttpURLConnection.HTTP_CREATED;
  44 import static java.net.HttpURLConnection.HTTP_NO_CONTENT;
  45 import static java.net.HttpURLConnection.HTTP_OK;
  46 import static java.util.Optional.empty;
  47 import static java.util.Optional.of;
  48 import static java.util.Optional.ofNullable;
  49
  50 public class GithubApplicationHttpClientImpl implements GithubApplicationHttpClient {
  51
  52   private static final Logger LOG = Loggers.get(GithubApplicationHttpClientImpl.class);
  53   private static final Pattern NEXT_LINK_PATTERN = Pattern.compile(".*<(.*)>; rel=\"next\"");
  54   private static final String MACHINE_MAN_PREVIEW_JSON = "application/vnd.github.machine-man-preview+json";
  55   private static final String ANTIOPE_PREVIEW_JSON = "application/vnd.github.antiope-preview+json";
  56
  57   private final OkHttpClient client;
  58
  59   public GithubApplicationHttpClientImpl(TimeoutConfiguration timeoutConfiguration) {
  60     client = new OkHttpClientBuilder()
  61         .setConnectTimeoutMs(timeoutConfiguration.getConnectTimeout())
  62         .setReadTimeoutMs(timeoutConfiguration.getReadTimeout())
  63         .build();
  64   }
  65
  66   @Override
  67   public GetResponse get(String appUrl, AccessToken token, String endPoint) throws IOException {
  68     validateEndPoint(endPoint);
  69
  70     try (okhttp3.Response response = client.newCall(newGetRequest(appUrl, token, endPoint)).execute()) {
  71       int responseCode = response.code();
  72       if (responseCode != HTTP_OK) {
  73         LOG.warn("GET response did not have expected HTTP code (was {}): {}", responseCode, attemptReadContent(response));
  74         return new GetResponseImpl(responseCode, null, null);
  75       }
  76       return new GetResponseImpl(responseCode, readContent(response.body()).orElse(null), readNextEndPoint(response));
  77     }
  78   }
  79
  80   private static void validateEndPoint(String endPoint) {
  81     checkArgument(endPoint.startsWith("/") || endPoint.startsWith("http"), "endpoint must start with '/' or 'http'");
  82   }
  83
  84   private static Request newGetRequest(String appUrl, AccessToken token, String endPoint) {
  85     return newRequestBuilder(appUrl, token, endPoint).get().build();
  86   }
  87
  88   @Override
  89   public Response post(String appUrl, AccessToken token, String endPoint) throws IOException {
  90     return doPost(appUrl, token, endPoint, new FormBody.Builder().build());
  91   }
  92
  93   @Override
  94   public Response post(String appUrl, AccessToken token, String endPoint, String json) throws IOException {
  95     RequestBody body = RequestBody.create(json, MediaType.parse("application/json; charset=utf-8"));
  96     return doPost(appUrl, token, endPoint, body);
  97   }
  98
  99   @Override
 100   public Response patch(String appUrl, AccessToken token, String endPoint, String json) throws IOException {
 101     RequestBody body = RequestBody.create(json, MediaType.parse("application/json; charset=utf-8"));
 102     return doPatch(appUrl, token, endPoint, body);
 103   }
 104
 105   @Override
 106   public Response delete(String appUrl, AccessToken token, String endPoint) throws IOException {
 107     validateEndPoint(endPoint);
 108
 109     try (okhttp3.Response response = client.newCall(newDeleteRequest(appUrl, token, endPoint)).execute()) {
 110       int responseCode = response.code();
 111       if (responseCode != HTTP_NO_CONTENT) {
 112         String content = attemptReadContent(response);
 113         LOG.warn("DELETE response did not have expected HTTP code (was {}): {}", responseCode, content);
 114         return new ResponseImpl(responseCode, content);
 115       }
 116       return new ResponseImpl(responseCode, null);
 117     }
 118   }
 119
 120   private static Request newDeleteRequest(String appUrl, AccessToken token, String endPoint) {
 121     return newRequestBuilder(appUrl, token, endPoint).delete().build();
 122   }
 123
 124   private Response doPost(String appUrl, @Nullable AccessToken token, String endPoint, RequestBody body) throws IOException {
 125     validateEndPoint(endPoint);
 126
 127     try (okhttp3.Response response = client.newCall(newPostRequest(appUrl, token, endPoint, body)).execute()) {
 128       int responseCode = response.code();
 129       if (responseCode == HTTP_OK || responseCode == HTTP_CREATED) {
 130         return new ResponseImpl(responseCode, readContent(response.body()).orElse(null));
 131       } else if (responseCode == HTTP_NO_CONTENT) {
 132         return new ResponseImpl(responseCode, null);
 133       }
 134       String content = attemptReadContent(response);
 135       LOG.warn("POST response did not have expected HTTP code (was {}): {}", responseCode, content);
 136       return new ResponseImpl(responseCode, content);
 137     }
 138   }
 139
 140   private Response doPatch(String appUrl, AccessToken token, String endPoint, RequestBody body) throws IOException {
 141     validateEndPoint(endPoint);
 142
 143     try (okhttp3.Response response = client.newCall(newPatchRequest(token, appUrl, endPoint, body)).execute()) {
 144       int responseCode = response.code();
 145       if (responseCode == HTTP_OK) {
 146         return new ResponseImpl(responseCode, readContent(response.body()).orElse(null));
 147       } else if (responseCode == HTTP_NO_CONTENT) {
 148         return new ResponseImpl(responseCode, null);
 149       }
 150       String content = attemptReadContent(response);
 151       LOG.warn("PATCH response did not have expected HTTP code (was {}): {}", responseCode, content);
 152       return new ResponseImpl(responseCode, content);
 153     }
 154   }
 155
 156   private static Request newPostRequest(String appUrl, @Nullable AccessToken token, String endPoint, RequestBody body) {
 157     return newRequestBuilder(appUrl, token, endPoint).post(body).build();
 158   }
 159
 160   private static Request newPatchRequest(AccessToken token, String appUrl, String endPoint, RequestBody body) {
 161     return newRequestBuilder(appUrl, token, endPoint).patch(body).build();
 162   }
 163
 164   private static Request.Builder newRequestBuilder(String appUrl, @Nullable AccessToken token, String endPoint) {
 165     Request.Builder url = new Request.Builder()
 166         .url(toAbsoluteEndPoint(appUrl, endPoint));
 167     if (token != null) {
 168       url
 169           .addHeader("Authorization", token.getAuthorizationHeaderPrefix() + " " + token)
 170           // TODO: Remove when CheckAPI is no longer in beta
 171           .addHeader("Accept", ANTIOPE_PREVIEW_JSON + ", " + MACHINE_MAN_PREVIEW_JSON);
 172     }
 173     return url;
 174   }
 175
 176   private static String toAbsoluteEndPoint(String host, String endPoint) {
 177     if (endPoint.startsWith("http")) {
 178       return endPoint;
 179     }
 180     try {
 181       return new URL(host + endPoint).toExternalForm();
 182     } catch (MalformedURLException e) {
 183       throw new IllegalArgumentException(String.format("%s is not a valid url", host + endPoint));
 184     }
 185   }
 186
 187   private static String attemptReadContent(okhttp3.Response response) {
 188     try {
 189       return readContent(response.body()).orElse(null);
 190     } catch (IOException e) {
 191       return null;
 192     }
 193   }
 194
 195   private static Optional<String> readContent(@Nullable ResponseBody body) throws IOException {
 196     if (body == null) {
 197       return empty();
 198     }
 199     try {
 200       return of(body.string());
 201     } finally {
 202       body.close();
 203     }
 204   }
 205
 206   @CheckForNull
 207   private static String readNextEndPoint(okhttp3.Response response) {
 208     String links = response.header("link");
 209     if (links == null || links.isEmpty() || !links.contains("rel=\"next\"")) {
 210       return null;
 211     }
 212
 213     Matcher nextLinkMatcher = NEXT_LINK_PATTERN.matcher(links);
 214     if (!nextLinkMatcher.find()) {
 215       return null;
 216     }
 217
 218     return nextLinkMatcher.group(1);
 219   }
 220
 221   private static class ResponseImpl implements Response {
 222     private final int code;
 223     private final String content;
 224
 225     private ResponseImpl(int code, @Nullable String content) {
 226       this.code = code;
 227       this.content = content;
 228     }
 229
 230     @Override
 231     public int getCode() {
 232       return code;
 233     }
 234
 235     @Override
 236     public Optional<String> getContent() {
 237       return ofNullable(content);
 238     }
 239   }
 240
 241   private static final class GetResponseImpl extends ResponseImpl implements GetResponse {
 242     private final String nextEndPoint;
 243
 244     private GetResponseImpl(int code, @Nullable String content, @Nullable String nextEndPoint) {
 245       super(code, content);
 246       this.nextEndPoint = nextEndPoint;
 247     }
 248
 249     @Override
 250     public Optional<String> getNextEndPoint() {
 251       return ofNullable(nextEndPoint);
 252     }
 253   }
 254 }