- use redirect handling from httpclient

- improve proxy handling (Forward, reverse)

Author: MCMicS

gradle.properties

@@ -1,19 +1,16 @@
 # IntelliJ Platform Artifacts Repositories
 # -> https://plugins.jetbrains.com/docs/intellij/intellij-artifacts.html
-
-pluginGroup = org.codinjutsu
-pluginName = jenkins-control-plugin
+pluginGroup=org.codinjutsu
+pluginName=jenkins-control-plugin
 # SemVer format -> https://semver.org
-pluginVersion = 0.13.17-eap4
-
+pluginVersion=0.13.17-eap5
 # See https://plugins.jetbrains.com/docs/intellij/build-number-ranges.html
 # for insight into build numbers and IntelliJ Platform versions.
-pluginSincePlatformVersion = 2022.2
-pluginSinceBuild = 222.2964
-pluginUntilBuild =
-
+pluginSincePlatformVersion=2022.2
+pluginSinceBuild=222.2964
+pluginUntilBuild=
 # IntelliJ Platform Properties -> https://github.com/JetBrains/gradle-intellij-plugin#intellij-platform-properties
-platformType = IC
+platformType=IC
 #Rider
 #platformType = RD
 #Android
@@ -25,25 +22,20 @@ platformType = IC
 #platformVersion = 222-EAP-SNAPSHOT
 #platformVersion = 222-EAP-SNAPSHOT
 #platformVersion = 223-EAP-SNAPSHOT
-platformVersion = 2022.2
+platformVersion=2022.2
 #platformVersion = 2022.3
-platformVersionToVerify = 222.2964.55
-
+platformVersionToVerify=222.2964.55
 # Plugin Dependencies -> https://plugins.jetbrains.com/docs/intellij/plugin-dependencies.html
 # Example: platformPlugins = com.intellij.java, com.jetbrains.php:203.4449.22, com.intellij.kubernetes
-platformPlugins = com.intellij.java
-
+platformPlugins=com.intellij.java
 # Java language level used to compile sources and to generate the files for - Java 11 is required since 2020.3
-javaVersion = 11
-javaVersionTarget = 11
-
+javaVersion=11
+javaVersionTarget=11
 # Gradle Releases -> https://github.com/gradle/gradle/releases
-gradleVersion = 7.4.2
-
+gradleVersion=7.4.2
 # Opt-out flag for bundling Kotlin standard library.
 # See https://plugins.jetbrains.com/docs/intellij/kotlin.html#kotlin-standard-library for details.
 # suppress inspection "UnusedProperty"
-kotlin.stdlib.default.dependency = false
-
+kotlin.stdlib.default.dependency=false
 # https://plugins.jetbrains.com/docs/intellij/tools-gradle-intellij-plugin.html#build-features
 org.jetbrains.intellij.buildFeature.buildFeatureName=false

src/main/java/org/codinjutsu/tools/jenkins/logic/JenkinsNotifier.java

@@ -1,15 +1,23 @@
 package org.codinjutsu.tools.jenkins.logic;
 
 import com.intellij.ide.BrowserUtil;
+import com.intellij.ide.DataManager;
 import com.intellij.notification.*;
+import com.intellij.openapi.actionSystem.CommonDataKeys;
 import com.intellij.openapi.components.Service;
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
+import org.codinjutsu.tools.jenkins.util.GuiUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.function.Consumer;
+
 @Service
 public final class JenkinsNotifier {
 
+    private static final Logger LOG = Logger.getInstance(JenkinsNotifier.class);
+
     private final NotificationGroup jenkinsGroup;
     @Nullable
     private final Project project;
@@ -25,6 +33,18 @@ public static JenkinsNotifier getInstance(@NotNull Project project) {
         return jenkinsNotifier == null ? new JenkinsNotifier(project) : jenkinsNotifier;
     }
 
+    public static void notifyForCurrentContext(String content, NotificationType notificationType) {
+        notifyForCurrentContext(jenkinsNotifier -> jenkinsNotifier.notify(content, notificationType));
+    }
+
+    public static void notifyForCurrentContext(Consumer<JenkinsNotifier> jenkinsNotifier) {
+        GuiUtil.runInSwingThread(() -> DataManager.getInstance().getDataContextFromFocusAsync()
+                .then(CommonDataKeys.PROJECT::getData)
+                .then(JenkinsNotifier::getInstance)
+                .onSuccess(jenkinsNotifier)
+                .onError(LOG::error));
+    }
+
     @NotNull
     public Notification error(String content) {
         return error(project, content);

src/main/java/org/codinjutsu/tools/jenkins/security/BasicSecurityClient.java

@@ -57,11 +57,14 @@ private String doAuthentication(URL jenkinsUrl) throws AuthenticationException {
             final var targetHost = new HttpHost(jenkinsUrl.getHost(), jenkinsUrl.getPort(), jenkinsUrl.getProtocol());
             final var credentials = new UsernamePasswordCredentials(username, password);
             addAuthenticationPreemptive(targetHost, credentials);
+
+            final var redirectTarget = getLastRedirectionHost(targetHost);
+            addAuthenticationPreemptive(redirectTarget, credentials);
         }
 
         final var post = createPost(jenkinsUrl.toString(), Collections.emptyList());
         try {
-            final var response = executeHttpFollowRedirect(post);
+            final var response = executeHttp(post);
             final var responseCode = response.getStatusLine().getStatusCode();
             final var responseBody = EntityUtils.toString(response.getEntity());
             LOG.trace(String.format("Call url '%s' --> Status: %s, Data %s", jenkinsUrl, responseCode,

src/main/java/org/codinjutsu/tools/jenkins/security/DefaultSecurityClient.java

@@ -16,65 +16,60 @@
 
 package org.codinjutsu.tools.jenkins.security;
 
-import com.github.cliftonlabs.json_simple.JsonObject;
-import com.github.cliftonlabs.json_simple.Jsoner;
+import com.intellij.notification.NotificationType;
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.util.net.IdeHttpClientHelpers;
 import com.intellij.util.net.ssl.CertificateManager;
 import org.apache.commons.lang.StringUtils;
-import org.apache.http.HttpHeaders;
 import org.apache.http.HttpHost;
 import org.apache.http.HttpResponse;
 import org.apache.http.auth.AuthScope;
 import org.apache.http.auth.UsernamePasswordCredentials;
 import org.apache.http.client.AuthCache;
 import org.apache.http.client.CredentialsProvider;
 import org.apache.http.client.config.RequestConfig;
+import org.apache.http.client.methods.HttpHead;
 import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.methods.HttpRequestBase;
 import org.apache.http.client.methods.HttpUriRequest;
 import org.apache.http.client.protocol.HttpClientContext;
 import org.apache.http.config.SocketConfig;
-import org.apache.http.entity.ContentType;
-import org.apache.http.entity.mime.MultipartEntityBuilder;
 import org.apache.http.impl.auth.BasicScheme;
 import org.apache.http.impl.client.BasicAuthCache;
 import org.apache.http.impl.client.BasicCredentialsProvider;
 import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.impl.client.HttpClients;
-import org.apache.http.protocol.HttpContext;
 import org.apache.http.util.EntityUtils;
 import org.codinjutsu.tools.jenkins.exception.AuthenticationException;
 import org.codinjutsu.tools.jenkins.exception.ConfigurationException;
-import org.codinjutsu.tools.jenkins.exception.JenkinsPluginRuntimeException;
-import org.codinjutsu.tools.jenkins.model.FileParameter;
+import org.codinjutsu.tools.jenkins.logic.JenkinsNotifier;
 import org.codinjutsu.tools.jenkins.model.RequestData;
-import org.codinjutsu.tools.jenkins.model.VirtualFilePart;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import javax.net.ssl.SSLContext;
 import java.io.IOException;
 import java.net.HttpURLConnection;
-import java.net.URI;
 import java.net.URL;
 import java.net.UnknownHostException;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.util.Collection;
+import java.util.Optional;
 import java.util.function.Function;
 
 class DefaultSecurityClient implements SecurityClient {
 
-    private static final String BAD_CRUMB_DATA = "No valid crumb was included in the request";
     static final Charset CHARSET = StandardCharsets.UTF_8;
-    static final String CHARSET_NAME = CHARSET.name();
+    private static final Logger LOG = Logger.getInstance(DefaultSecurityClient.class);
+    private static final String BAD_CRUMB_DATA = "No valid crumb was included in the request";
     private final CloseableHttpClient httpClient;
-    protected @Deprecated String crumbData;
-    protected JenkinsVersion jenkinsVersion = JenkinsVersion.VERSION_1;
     private final CredentialsProvider credentialsProvider;
     private final AuthCache authCache;
     private final HttpClientContext httpClientContext;
-
     private final Function<String, RequestConfig> configCreator;
+    protected @Deprecated String crumbData;
+    protected JenkinsVersion jenkinsVersion = JenkinsVersion.VERSION_1;
 
     DefaultSecurityClient(String crumbData, int connectionTimout) {
         this(crumbData, connectionTimout, CertificateManager.getInstance().getSslContext(), true);
@@ -90,13 +85,15 @@ class DefaultSecurityClient implements SecurityClient {
                 .setSocketTimeout(connectionTimout);
         this.credentialsProvider = new BasicCredentialsProvider();
 
-        final RequestConfig defaultRequestConfig = requestConfig.build();
+        final RequestConfig defaultRequestConfig = requestConfig
+                .setMaxRedirects(10)
+                .build();
         final var httpClientBuilder = HttpClients.custom()
                 .setSSLContext(sslContext)
                 .setDefaultSocketConfig(socketConfig)
                 .setDefaultRequestConfig(defaultRequestConfig)
                 .setDefaultCredentialsProvider(credentialsProvider)
-                .disableRedirectHandling();
+                .setRedirectStrategy(new JenkinsRedirectStrategy());
         this.httpClient = httpClientBuilder.build();
         if (useProxySettings) {
             this.configCreator = url -> {
@@ -125,7 +122,7 @@ public String connect(URL jenkinsUrl) {
     public @NotNull Response execute(URL url, @NotNull Collection<RequestData> data) {
         String urlStr = url.toString();
 
-        ResponseCollector responseCollector = new ResponseCollector();
+        final var responseCollector = new ResponseCollector();
         runMethod(urlStr, data, responseCollector);
 
         if (isRedirection(responseCollector.statusCode)) {
@@ -136,7 +133,7 @@ public String connect(URL jenkinsUrl) {
     }
 
     @Override
-    public @NotNull HttpContext getHttpClientContext() {
+    public @NotNull HttpClientContext getHttpClientContext() {
         return this.httpClientContext;
     }
 
@@ -163,27 +160,12 @@ public String connect(URL jenkinsUrl) {
      * </pre>
      */
     @NotNull
-    HttpPost createPost(String url, @NotNull Collection<RequestData> data) {
-        final var post = new HttpPost(url);
-        if (!data.isEmpty()) {
-            final var multipartEntity = MultipartEntityBuilder.create();
-
-            data.stream().filter(FileParameter.class::isInstance)
-                    .map(FileParameter.class::cast)
-                    .forEach(fileParameter -> addMultipartBinaryBody(fileParameter, multipartEntity));
-
-            final var parameterJson = new JsonObject();
-            parameterJson.put("parameter", data);
-            multipartEntity.addTextBody("json", Jsoner.serialize(parameterJson), ContentType.APPLICATION_JSON)
-                    .setCharset(DefaultSecurityClient.CHARSET);
-            final var multipart = multipartEntity.build();
-            post.setEntity(multipart);
-        }
-
+    JenkinsPost createPost(String url, @NotNull Collection<RequestData> data) {
+        final var post = new JenkinsPost(url);
+        post.setData(data);
         if (isCrumbDataSet()) {
             post.addHeader(jenkinsVersion.getCrumbName(), crumbData);
         }
-        post.addHeader(HttpHeaders.ACCEPT_LANGUAGE, "en-US,en;q=0.5");
         return post;
     }
 
@@ -193,14 +175,34 @@ protected final void addAuthenticationPreemptive(HttpHost host, UsernamePassword
         credentialsProvider.setCredentials(authScope, credentials);
     }
 
-    private void addMultipartBinaryBody(FileParameter fileParameter,
-                                        MultipartEntityBuilder multipartEntityBuilder) {
-        final var virtualFilePart = new VirtualFilePart(fileParameter.getFile());
+    protected final HttpHost getLastRedirectionHost(HttpHost host) {
+        final var httpHead = new HttpHead(host.toURI());
         try {
-            multipartEntityBuilder.addBinaryBody(fileParameter.getFileName(), virtualFilePart.createInputStream(),
-                    ContentType.APPLICATION_OCTET_STREAM, virtualFilePart.getFileName());
-        } catch (IOException e) {
-            throw new JenkinsPluginRuntimeException(e.getMessage(), e);
+            final var context = getHttpClientContext();
+            final var response = executeHttp(httpHead);
+            final var statusCode = response.getStatusLine().getStatusCode();
+
+            var targetHost = host;
+            if (HttpURLConnection.HTTP_OK == statusCode) {
+                final var locations = context.getRedirectLocations();
+                if (locations != null) {
+                    final var lastHost = locations.get(locations.size() - 1).toURL();
+                    targetHost = new HttpHost(lastHost.getHost(), lastHost.getPort(), lastHost.getProtocol());
+                }
+            }
+            return targetHost;
+        } catch (IOException cause) {
+            final var errorMessage = Optional.ofNullable(cause.getMessage())
+                    .orElseGet(() -> Optional.ofNullable(cause.getCause())
+                            .map(Throwable::getMessage)
+                            .orElse(String.valueOf(cause.getClass())));
+            final String message = String.format("IO Error during retrieve last Host for Redirection for URL '%s': %s",
+                    httpHead.getURI(), errorMessage);
+            LOG.info(message, cause);
+            JenkinsNotifier.notifyForCurrentContext(message, NotificationType.WARNING);
+            return host;
+        } finally {
+            httpHead.releaseConnection();
         }
     }
 
@@ -217,12 +219,12 @@ private void runMethod(String url, @NotNull Collection<RequestData> data, Respon
             if (HttpURLConnection.HTTP_OK == statusCode) {
                 responseCollector.collect(statusCode, responseBody);
             } else {
-                responseCollector.statusCode(statusCode);
+                responseCollector.collect(statusCode, response.getStatusLine().getReasonPhrase());
             }
             if (errorHeader != null) {
                 responseCollector.error(errorHeader.getValue());
             }
-            // ToDo @mcmics enable redirection in httpclient again and try to remove following
+            // if redirect handling not works or we still get a redirect header we handle it manually
             if (isRedirection(statusCode)) {
                 responseCollector.collect(statusCode, response.getLastHeader("Location").getValue());
             }
@@ -241,20 +243,11 @@ protected final HttpResponse executeHttp(HttpPost post) throws IOException {
         if (postConfig == null) {
             post.setConfig(configCreator.apply(post.getURI().toASCIIString()));
         }
-
-        return httpClient.execute(post, this.httpClientContext);
+        return executeHttp((HttpRequestBase) post);
     }
 
-    protected final HttpResponse executeHttpFollowRedirect(HttpPost post) throws IOException {
-        var response = executeHttp(post);
-        final var statusCode = response.getStatusLine().getStatusCode();
-
-        if (isRedirection(statusCode)) {
-            final var location = response.getLastHeader("Location").getValue();
-            post.setURI(URI.create(location));
-            response = executeHttp(post);
-        }
-        return response;
+    protected final HttpResponse executeHttp(HttpRequestBase httpRequest) throws IOException {
+        return getHttpClient().execute(httpRequest, this.httpClientContext);
     }
 
     protected void checkResponse(int statusCode, String responseBody) throws AuthenticationException {