Application: gvSIG desktop

package org.gvsig.downloader.lib.impl;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStreamWriter;

import java.net.HttpURLConnection;

import java.net.SocketTimeoutException;

import java.net.URL;

import java.util.Objects;

import java.util.concurrent.Executor;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.http.Header;

import org.apache.http.HttpEntity;

import org.apache.http.HttpResponse;

import org.apache.http.auth.AuthenticationException;

import org.apache.http.client.ClientProtocolException;

import org.apache.http.client.ResponseHandler;

import org.apache.http.client.config.RequestConfig;

import org.apache.http.client.methods.HttpDelete;

import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;

import org.apache.http.client.methods.HttpGet;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.client.methods.HttpPut;

import org.apache.http.client.methods.HttpRequestBase;

import org.apache.http.client.methods.HttpUriRequest;

import org.apache.http.conn.ConnectTimeoutException;

import org.apache.http.entity.ContentType;

import org.apache.http.entity.StringEntity;

import org.apache.http.impl.client.CloseableHttpClient;

import org.apache.http.impl.client.HttpClientBuilder;

import org.gvsig.compat.se.net.downloader.se.AbstractSEDownloaderTask;

import org.gvsig.compat.se.net.downloader.se.SEDownloader;

import org.gvsig.downloader.DownloaderAuthenticationConfig;

import org.gvsig.downloader.DownloaderAuthenticationRequester;

import org.gvsig.downloader.DownloaderCredentials;

@SuppressWarnings("UseSpecificCatch")

final class SEAuthDownloaderTask

        extends AbstractSEDownloaderTask

        implements Runnable {

    private class DownloaderResponseHandler implements ResponseHandler<Object> {

        private int status;

        private HttpResponse response;

        public DownloaderResponseHandler() {

            this.status = 0;

         }

        @Override

        public Object handleResponse(HttpResponse response) throws ClientProtocolException, IOException {

            this.status=response.getStatusLine().getStatusCode();

            this.response = response;

            try {

                HttpEntity entity = response.getEntity();

                if(entity == null) {

                    download(null);

                } else {

                    InputStream content = entity.getContent();

                    download(content);

                }

            } catch (IOExceptionWithStatus ex) {

                throw ex;

            } catch (Exception ex) {

                throw new IOExceptionWithStatus(this.status, ex.getLocalizedMessage(), ex);

            }

            return null;

        }

        private int getStatus() {

            return this.status;

        }

    }

    private static final String METHOD_PUT = "PUT";

    private static final String METHOD_POST = "POST";

    private static final String METHOD_GET = "GET";

    private static final String METHOD_DELETE = "DELETE";

    public SEAuthDownloaderTask(SEDownloader downloader, URL url, String data, File dstFile, Object groupID) {

        super(downloader, url, data, dstFile, groupID);

    }

    private DownloaderManagerImpl getDownloader() {

        return (DownloaderManagerImpl) this.downloader;

    }

    private DownloaderCredentials getCredentials() {

        return this.getDownloader().getCredentials(this.url);

    }

    private void addOrReplaceCredentials(DownloaderCredentials credentials) {

        this.getDownloader().addOrReplaceCredentials(credentials);

    }

    private DownloaderAuthenticationConfig getServiceAuthorizationConfig() {

        return this.getDownloader().getAuthenticationConfigurationService(this.url.toString());

    }

    private void authorize() {

        try {

            LOGGER.info("AUTHORIZATION REQUIRED");

            DownloaderAuthenticationConfig config = this.getServiceAuthorizationConfig();

            if( config == null ) {

                config = this.getDownloader().requestAutenticationConfig(this.url);

                if( config == null ) {

                    throw new AuthenticationException("Not service authentication configured for url '"+this.url+"'.");

                }

            }

            DownloaderAuthenticationRequester authorizationRequester = config.create();

            if( authorizationRequester == null ) {

                throw new AuthenticationException("Can't configure service authentication for url '"+this.url+"'.");

            }

            LOGGER.info("AUTHORIZATION REQUESTER TYPE: "+authorizationRequester.getProviderName());

            if( !authorizationRequester.requestAuthorization(this.getExecutorUI()) ) {

                return;

            }

            DownloaderCredentials credentials = authorizationRequester.getCredentials();

            addOrReplaceCredentials(credentials);

            LOGGER.info("CREDENTIALS: "+credentials.toString());

        } catch (Exception ex) {

            LOGGER.warn("Can't authorize", ex);

        }

    }

    private DownloaderResponseHandler executeRequest(HttpUriRequest request) throws IOException {

        int timeout = getTimeout();

        RequestConfig requestConfig = RequestConfig.custom()

            .setConnectTimeout(timeout)

            .setConnectionRequestTimeout(timeout)

            .setSocketTimeout(timeout)

            .build();

        CloseableHttpClient httpClient = HttpClientBuilder.create().setDefaultRequestConfig(requestConfig).build();

        DownloaderCredentials credentials = this.getCredentials();

        if (credentials==null ) {

            DownloaderAuthenticationConfig config = this.getServiceAuthorizationConfig();

            if( config!=null ) {

                DownloaderAuthenticationRequester authorizationRequester = config.create();

                if( authorizationRequester!=null ) {

                    if( authorizationRequester.requestAuthorization(this.getExecutorUI()) ) {

                        credentials = authorizationRequester.getCredentials();

                        addOrReplaceCredentials(credentials);

                        request.addHeader("Authorization", credentials.getAuthorizationToken());

                    }

                }

            }

        } else {

            request.addHeader("Authorization", credentials.getAuthorizationToken());

        }

        DownloaderResponseHandler responseHandler = new DownloaderResponseHandler();

        LOGGER.info("REQUEST "+request.getMethod()+" "+request.getURI().toString());

        LOGGER.info("TIMEOUT "+timeout);

        for (Header header : request.getAllHeaders()) {

            LOGGER.info(header.getName()+": "+header.getValue());

        }

        if( request instanceof HttpEntityEnclosingRequestBase ) {

            InputStream content = ((HttpEntityEnclosingRequestBase) request).getEntity().getContent();

            LOGGER.info("BODY data "+(StringUtils.join(IOUtils.readLines(content,"utf-8"),"\n")));

        }

        LOGGER.info("DOWNLOAD TO "+Objects.toString(dstFile));

        try {

            httpClient.execute(request,responseHandler);

        } catch (SocketTimeoutException|ConnectTimeoutException ex) {

            LOGGER.info("RESPONSE TIMEOUT");

            throw ex;

        } catch (Exception ex) {

            LOGGER.info("RESPONSE ERROR "+ex.getLocalizedMessage());

            throw ex;

        }

        LOGGER.info("RESPONSE CODE "+responseHandler.getStatus());

        return responseHandler;

    }

    public File send(String method) throws IOException {

        int status = 500;

        try {

            int numretries = 3;

            for (int retries = 0; retries < numretries; retries++) {

                HttpRequestBase request;

                switch (method.toUpperCase()) {

                    case METHOD_DELETE:

                        request = new HttpDelete(url.toURI());

                        break;

                    case METHOD_GET:

                    default:

                        request = new HttpGet(url.toURI());

                        break;

                }

//                request.setHeader("User-Agent","Mozilla/5.0 (gvSIG) like Gecko");

                request.setHeader("User-Agent","gvSIG-desktop");

                request.setHeader("Referer","http://www.gvsig.com");

                LOGGER.info("RETRY "+retries);

                DownloaderResponseHandler responseHandler = executeRequest(request);

                status = responseHandler.getStatus();

                if(status >= 200 && status < 300) {

                    //2xx success

                    return this.dstFile;

                } else if(status >= 300 && status < 400) {

                    // 3xx redirection

                    throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(url)+"' HTTPStatus = "+status);

                } else if(status == 401 || status == 403) {

                    // "401 Unauthorized" indicates that the request lacks valid authentication credentials

                    // "403 Forbidden" the client doesn't have permission to access the requested resource

                    // https://www.permit.io/blog/401-vs-403-error-whats-the-difference

                    if( retries < numretries-1 ) {

                        authorize();

                    }

                } else if(status >= 400 && status < 500) {

                    // 4xx client errors

                    throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(url)+"' HTTPStatus = "+status);

                } else if(status >= 500 && status < 600) {

                    // 5xx server errors

                    throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(url)+"' HTTPStatus = "+status);

                } else {

                    //Unknown

                    throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(url)+"' HTTPStatus = "+status);

                }

            }

            throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(url)+"' too many retries, last status " + status);

        } catch (IOExceptionWithStatus ex) {

            throw ex;

        } catch (Throwable ex) {

            throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(url)+"' last status " + status, ex);

        }

    }

    private File send(String method, ContentType contentType, String data) throws IOExceptionWithStatus {

        int status = 500;

        try {

            int numretries = 3;

            for (int retries = 0; retries < numretries; retries++) {

                HttpEntityEnclosingRequestBase request;

                switch (method.toUpperCase()) {

                    case METHOD_PUT:

                        request = new HttpPut(url.toURI());

                        break;

                    case METHOD_POST:

                    default:

                        request = new HttpPost(url.toURI());

                        request.setHeader("SOAPAction", "post");

                        break;

                }

                request.setEntity(new StringEntity(data, contentType));

//                request.setHeader("User-Agent","Mozilla/5.0 (gvSIG) like Gecko");

                request.setHeader("User-Agent","gvSIG-desktop");

                request.setHeader("Referer","http://www.gvsig.com");

                request.setHeader("Content-type", contentType.getMimeType());

                DownloaderResponseHandler responseHandler = executeRequest(request);

                status = responseHandler.getStatus();

                if(status >= 200 && status < 300) {

                    //2xx success

                    return this.dstFile;

                } else if(status >= 300 && status < 400) {

                    // 3xx redirection

                    throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(url)+"' HTTPStatus = "+status);

                } else if(status == 401 || status == 403) {

                    // "401 Unauthorized" indicates that the request lacks valid authentication credentials

                    // "403 Forbidden" the client doesn't have permission to access the requested resource

                    // https://www.permit.io/blog/401-vs-403-error-whats-the-difference

                    if( retries < numretries-1 ) {

                        authorize();

                    }

                } else if(status >= 400 && status < 500) {

                    // 4xx client errors

                    throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(url)+"' HTTPStatus = "+status);

                } else if(status >= 500 && status < 600) {

                    // 5xx server errors

                    throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(url)+"' HTTPStatus = "+status);

                } else {

                    //Unknown

                    throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(url)+"' HTTPStatus = "+status);

                }

            }

            throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(url)+"' too many retries, last status " + status);

        } catch (IOExceptionWithStatus ex) {

            throw ex;

        } catch (Throwable ex) {

            throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(url)+"' last status " + status, ex);

        }

    }

    @Override

    public void run() {

        try {

            if (data != null) {

                send(METHOD_POST, ContentType.TEXT_XML, this.data);

            } else {

                send(METHOD_GET);

            }

            postdownload();

        } catch (Exception e) {

            exception(e);

        }

//        LOGGER.debug("downloading '" + url.toString() + "' to: " + dstFile.getAbsolutePath());

//        if (data != null) {

//            LOGGER.debug("using POST, request = " + data);

//        }

//        int timeout = this.getTimeout();

//

//        try {

//            OutputStreamWriter os = null;

//            HttpURLConnection connection = null;

//

//            //If the used protocol is HTTPS

//            if (url.getProtocol().equals("https")) {

//                disableHttsValidation();

//            }

//            connection = (HttpURLConnection) url.openConnection();

//            connection.setUseCaches(false);

//            connection.setRequestProperty("User-Agent", "Mozilla/5.0 (gvSIG) like Gecko");

//            connection.setConnectTimeout(timeout);

//

//            //If it uses a HTTP POST

//            if (data != null) {

//                connection.setRequestProperty("SOAPAction", "post");

//                connection.setRequestMethod("POST");

//                connection.setDoOutput(true);

//                connection.setRequestProperty("Content-Type", "text/xml; charset=UTF-8");

//                os = new OutputStreamWriter(connection.getOutputStream());

//                os.write(data);

//                os.flush();

//            }

//            download(connection.getInputStream());

//

//            if (os != null) {

//                os.close();

//            }

//

//            postdownload();

//

//        } catch (Exception e) {

//            exception(e);

//        }

    }

    private Executor getExecutorUI()  {

        return this.downloader.getExecutorUI();

    }

}