| /** |
| * Copyright (c) 2015 Codetrails GmbH. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| */ |
| package org.eclipse.epp.internal.logging.aeri.ide.server.mars; |
| |
| import static com.google.common.base.Charsets.UTF_8; |
| import static java.lang.System.getProperty; |
| import static org.apache.commons.lang3.ArrayUtils.contains; |
| import static org.apache.commons.lang3.StringUtils.*; |
| import static org.eclipse.epp.internal.logging.aeri.ide.server.Proxies.*; |
| import static org.eclipse.epp.internal.logging.aeri.ide.server.mars.ServerResponse.KEYWORD_NEEDINFO; |
| import static org.eclipse.epp.logging.aeri.core.ProblemStatus.*; |
| import static org.eclipse.epp.logging.aeri.core.util.Links.REL_BUG; |
| |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.net.UnknownHostException; |
| import java.util.concurrent.TimeUnit; |
| |
| import org.apache.commons.lang3.StringUtils; |
| import org.apache.http.HttpEntity; |
| import org.apache.http.HttpResponse; |
| import org.apache.http.HttpStatus; |
| import org.apache.http.client.ClientProtocolException; |
| import org.apache.http.client.HttpResponseException; |
| import org.apache.http.client.entity.GzipCompressingEntity; |
| import org.apache.http.client.fluent.Executor; |
| import org.apache.http.client.fluent.Request; |
| import org.apache.http.client.fluent.Response; |
| import org.apache.http.entity.ContentType; |
| import org.apache.http.entity.StringEntity; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.emf.common.util.EMap; |
| import org.eclipse.epp.internal.logging.aeri.ide.l10n.LogMessages; |
| import org.eclipse.epp.internal.logging.aeri.ide.l10n.Messages; |
| import org.eclipse.epp.internal.logging.aeri.ide.server.Proxies; |
| import org.eclipse.epp.internal.logging.aeri.ide.server.json.Json; |
| import org.eclipse.epp.logging.aeri.core.ILink; |
| import org.eclipse.epp.logging.aeri.core.IModelFactory; |
| import org.eclipse.epp.logging.aeri.core.IProblemState; |
| import org.eclipse.epp.logging.aeri.core.IReport; |
| import org.eclipse.epp.logging.aeri.core.ProblemStatus; |
| import org.eclipse.epp.logging.aeri.core.util.Formats; |
| import org.eclipse.epp.logging.aeri.core.util.Links; |
| import org.eclipse.epp.logging.aeri.core.util.Logs; |
| |
| import com.google.common.annotations.VisibleForTesting; |
| |
| public class IO { |
| |
| private Executor executor; |
| private ServerConfiguration configuration; |
| private File configurationFile; |
| |
| public IO(Executor executor, File configurationFile) { |
| this.executor = executor; |
| this.configurationFile = configurationFile; |
| } |
| |
| // TODO test all remote cases for exceptions |
| public void refreshConfiguration(String serverUrl, IProgressMonitor monitor) |
| throws HttpResponseException, UnknownHostException, Exception { |
| Response response = request(newURI(serverUrl), executor); |
| String content = HttpResponses.getContentWithProgress(response, monitor); |
| configuration = Json.deserialize(content, ServerConfiguration.class); |
| configuration.setTimestamp(System.currentTimeMillis()); |
| } |
| |
| public void loadConfiguration() { |
| configuration = Json.deserialize(configurationFile, ServerConfiguration.class); |
| } |
| |
| public void saveConfiguration() { |
| Json.serialize(configuration, configurationFile); |
| } |
| |
| public ServerConfiguration getConfiguration() { |
| return configuration; |
| } |
| |
| public void setConfiguration(ServerConfiguration configuration) { |
| this.configuration = configuration; |
| } |
| |
| public IProblemState upload(IReport report, IProgressMonitor monitor) throws IOException { |
| String body = Json.toJson(report, false); |
| StringEntity stringEntity = new StringEntity(body, ContentType.APPLICATION_OCTET_STREAM.withCharset(UTF_8)); |
| // length of zipped conent is unknown, using the progress of the string-stream instead. |
| // download progress percentage will be accurate, download progress size will be too large by the compression factor |
| HttpEntity entity = new GzipCompressingEntity(HttpResponses.decorateForProgressMonitoring(stringEntity, monitor)); |
| |
| String submitUrl = configuration.getSubmitUrl(); |
| URI target = newURI(submitUrl); |
| Request request = Request.Post(target).viaProxy(getProxyHost(target).orNull()).body(entity) |
| .connectTimeout(configuration.getConnectTimeoutMs()).staleConnectionCheck(true) |
| .socketTimeout(configuration.getSocketTimeoutMs()); |
| setEclipseUuid(request, target); |
| String response = proxyAuthentication(executor, target).execute(request).returnContent().asString(); |
| ServerResponse raw = Json.deserialize(response, ServerResponse.class); |
| |
| IProblemState problemState = IModelFactory.eINSTANCE.createProblemState(); |
| |
| // this looks a bit weird: it's not a bug id but the public id of the submission... |
| String submissionUrl = raw.getSubmissionUrl().orNull(); |
| if (submissionUrl != null) { |
| Links.addLink(problemState, Links.REL_SUBMISSION, submissionUrl, Messages.LINK_TEXT_SUBMISSION); |
| } |
| if (raw.hasBug()) { |
| Links.addLink(problemState, REL_BUG, raw.getBugUrl().orNull(), |
| Formats.format(Messages.LINK_TEXT_BUG, raw.getBugId().or(Messages.LINK_TEXT_BUG_ID_NULL))); |
| } |
| |
| problemState.setStatus(tryParse(raw)); |
| String message = raw.getInformation().orNull(); |
| if (message != null && !StringUtils.contains(message, "</a>") && !StringUtils.contains(message, "{link")) { //$NON-NLS-1$ |
| // TODO temporary for Mars.1 servers in Neon: |
| // Server sends an 'additional' status message which may not contain any links. Let's append them in a generic way for Neon.M4 |
| message += appendLinks(problemState.getLinks()); |
| } |
| problemState.setMessage(message); |
| |
| String[] keywords = raw.getKeywords().orNull(); |
| if (keywords != null) { |
| for (String keyword : keywords) { |
| problemState.getNeedinfo().add(keyword); |
| } |
| } |
| |
| return problemState; |
| } |
| |
| // returns a string with all links. Separated by ' ' and with a leading ' ' if the list of links is not empty. |
| private String appendLinks(EMap<String, ILink> links) { |
| if (links.isEmpty()) { |
| return ""; //$NON-NLS-1$ |
| } |
| StringBuilder sb = new StringBuilder(); |
| for (ILink link : links.values()) { |
| sb.append(Formats.format(" {0,link}", link)); //$NON-NLS-1$ |
| } |
| return sb.toString(); |
| } |
| |
| private static URI newURI(String uri) throws IOException { |
| try { |
| return new URI(uri); |
| } catch (URISyntaxException e) { |
| throw new IOException("invalid server url: " + uri, e); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * |
| * @param monitor |
| * @return the {@link HttpStatus} |
| */ |
| public int downloadDatabase(File destination, IProgressMonitor monitor) throws IOException { |
| URI target = newURI(configuration.getProblemsUrl()); |
| // @formatter:off |
| Request request = Request.Get(target) |
| .viaProxy(getProxyHost(target).orNull()) |
| .connectTimeout(configuration.getConnectTimeoutMs()) |
| .staleConnectionCheck(true) |
| .socketTimeout(configuration.getSocketTimeoutMs()); |
| // @formatter:on |
| setEclipseUuid(request, target); |
| |
| Response response = Proxies.proxyAuthentication(executor, target).execute(request); |
| |
| HttpResponse returnResponse = HttpResponses.getResponseWithProgress(response, monitor); |
| int statusCode = returnResponse.getStatusLine().getStatusCode(); |
| |
| if (statusCode == HttpStatus.SC_OK) { |
| configuration.setProblemsZipLastDownloadTimestamp(System.currentTimeMillis()); |
| saveConfiguration(); |
| try (FileOutputStream out = new FileOutputStream(destination)) { |
| returnResponse.getEntity().writeTo(out); |
| } |
| } |
| return statusCode; |
| } |
| |
| public boolean isProblemsDatabaseOutdated() { |
| return System.currentTimeMillis() - configuration.getProblemsZipLastDownloadTimestamp() > configuration.getProblemsTtlMs(); |
| } |
| |
| public boolean isConfigurationOutdated() { |
| if (configuration == null) { |
| return true; |
| } |
| return System.currentTimeMillis() - configuration.getTimestamp() > configuration.getTtlMs(); |
| } |
| |
| @VisibleForTesting |
| public static Response request(URI target, Executor executor) throws ClientProtocolException, IOException { |
| // max time until a connection to the server has to be established. |
| int connectTimeout = (int) TimeUnit.SECONDS.toMillis(3); |
| // max time between two packets sent back to the client. 10 seconds of silence will kill the session |
| int socketTimeout = (int) TimeUnit.SECONDS.toMillis(10); |
| Request request = Request.Get(target).viaProxy(getProxyHost(target).orNull()).connectTimeout(connectTimeout) |
| .staleConnectionCheck(true).socketTimeout(socketTimeout); |
| setEclipseUuid(request, target); |
| return proxyAuthentication(executor, target).execute(request); |
| } |
| |
| private static void setEclipseUuid(Request request, URI target) { |
| try { |
| if (!endsWith(target.getHost(), "eclipse.org")) { |
| return; |
| } |
| String eclipseUuid = defaultIfBlank(getProperty("eclipse.uuid"), "unknownUUID"); |
| request.setHeader("eclipse.uuid", eclipseUuid); |
| } catch (Exception e) { |
| Logs.warn("Failed to set eclipse.uuid", e); |
| } |
| } |
| |
| @VisibleForTesting |
| public static ProblemStatus tryParse(ServerResponse response) { |
| |
| boolean needinfo = contains(response.keywords, KEYWORD_NEEDINFO); |
| // public enum Status { UNCONFIRMED, NEW, ASSIGNED, RESOLVED, CLOSED, UNKNOWN } |
| String status = response.getStatus().or("").toUpperCase(); //$NON-NLS-1$ |
| // public enum Resolution { UNSPECIFIED, FIXED, DUPLICATE, WONTFIX, WORKSFORME, INVALID, UNKNOWN } |
| String resolution = response.getResolved().or("").toUpperCase(); //$NON-NLS-1$ |
| |
| switch (resolution) { |
| case "": //$NON-NLS-1$ |
| case "UNSPECIFIED": //$NON-NLS-1$ |
| // TODO UNSPECIFIED + UNCONFIRMED is used by AERI in the case of some internal error... Not sure whether we should keep that as |
| // is. |
| case "UNDEFINED": //$NON-NLS-1$ |
| case "UNKNONW": //$NON-NLS-1$ |
| // TODO investigate whether incorrectly spelt String "UNKNONW" is needed here |
| case "UNKNOWN": //$NON-NLS-1$ |
| if (needinfo) { |
| return NEEDINFO; |
| } else if (response.created) { |
| return NEW; |
| } |
| switch (status) { |
| case "UNCONFIRMED": //$NON-NLS-1$ |
| case "NEW": //$NON-NLS-1$ |
| case "ASSIGNED": //$NON-NLS-1$ |
| case "REOPEN": //$NON-NLS-1$ |
| return CONFIRMED; |
| } |
| // TODO happens when server returns UNKNOWN: |
| Logs.log(LogMessages.WARN_UNEXPECTED_SERVER_RESPONSE, status, response); |
| return UNCONFIRMED; |
| case "INVALID": //$NON-NLS-1$ |
| return INVALID; |
| case "FIXED": //$NON-NLS-1$ |
| return FIXED; |
| case "MOVED": //$NON-NLS-1$ |
| case "NOT_ECLIPSE": //$NON-NLS-1$ |
| case "WONTFIX": //$NON-NLS-1$ |
| case "WORKSFORME": //$NON-NLS-1$ |
| case "DUPLICATE": //$NON-NLS-1$ |
| return INVALID; |
| default: |
| return UNCONFIRMED; |
| } |
| } |
| } |
