Application: gvSIG desktop

package org.gvsig.downloader.lib.impl;

import org.gvsig.downloader.IOExceptionWithStatus;

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;

import org.gvsig.downloader.DownloaderManager;

@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;

        }

        public int getStatus() {

            return this.status;

        }

        public String getRedirectionLocation() {

            try {

                Header header = this.response.getFirstHeader("Location");

                if(header != null) {

                    return header.getValue();

                }

            } catch (Exception ex) {

                LOGGER.debug("Can't get redirection location", ex);

            }

            return null;

        }

    }

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

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

    }

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

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

    }

    private DownloaderManagerImpl getDownloader() {

        return (DownloaderManagerImpl) this.downloader;

    }

    private DownloaderCredentials getCredentials(URL url) { 

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

    }

    private void addOrReplaceCredentials(DownloaderCredentials credentials) { 

        this.getDownloader().addOrReplaceCredentials(credentials);

    }

    private DownloaderAuthenticationConfig getServiceAuthorizationConfig(URL url) { 

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

    }

    private void authorize(URL url) {

        try {

            LOGGER.info("AUTHORIZATION REQUIRED");

            DownloaderAuthenticationConfig config = this.getServiceAuthorizationConfig(url);

            if( config == null ) {

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

                if( config == null ) {

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

                }

            }

            DownloaderAuthenticationRequester authorizationRequester = config.create();

            if( authorizationRequester == null ) {

                throw new AuthenticationException("Can't configure service authentication for url '"+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();

        URL theUrl = request.getURI().toURL();

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

        DownloaderCredentials credentials = this.getCredentials(theUrl);

        if (credentials == null || credentials.isAuthorizationTokenExpired()) {

            DownloaderAuthenticationConfig config = this.getServiceAuthorizationConfig(theUrl);

            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;

        }

        int status =responseHandler.getStatus();

        if(status == 307 || status == 308){

            LOGGER.info("RESPONSE LOCATION "+Objects.toString(responseHandler.getRedirectionLocation()));

        }

        LOGGER.info("RESPONSE CODE "+status);

        return responseHandler;

    }

//    public File send(String method) throws IOException {

//        int status = 500;

//        URL theUrl = url;

//        try {

//            int numretries = 3;

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

//                HttpRequestBase request;

//                switch (method.toUpperCase()) {

//                    case METHOD_DELETE:

//                        request = new HttpDelete(theUrl.toURI());

//                        break;

//                    case METHOD_GET:

//                    default:

//                        request = new HttpGet(theUrl.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 == 307 || status == 308) {

//                    String redirection = responseHandler.getRedirectionLocation();

//                    if(StringUtils.isBlank(redirection)) {

//                        throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(theUrl)+"' HTTPStatus = "+status+" redirect to blank URL.");

//                    }

//                    try {

//                        theUrl = new URL(redirection);

//                    } catch (Exception ex) {

//                        throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(theUrl)+"' HTTPStatus = "+status+" redirect to invalid URL "+redirection);

//                    }

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

//                    // 3xx redirection

//                    throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(theUrl)+"' 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(theUrl);

//                    }

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

//                    // 4xx client errors

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

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

//                    // 5xx server errors

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

//                } else {

//                    //Unknown

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

//                }

//            }

//            throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(theUrl)+"' 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(theUrl)+"' last status " + status, ex);

//        }

//    }

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

        int status = 500;

        URL theUrl = url;

        try {

            int numretries = 3;

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

                HttpRequestBase request;

                switch (method.toUpperCase()) {

                    case DownloaderManager.METHOD_DELETE:

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

                        break;

                    case DownloaderManager.METHOD_PUT:

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

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

                        break;

                    case DownloaderManager.METHOD_POST:

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

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

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

                        break;

                    case DownloaderManager.METHOD_GET:

                    default:

                        request = new HttpGet(theUrl.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");

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

                DownloaderResponseHandler responseHandler = executeRequest(request);

                status = responseHandler.getStatus();

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

                    //2xx success

                    return this.dstFile;

                } else if(status == 307 || status == 308) {

                    String redirection = responseHandler.getRedirectionLocation();

                    if(StringUtils.isBlank(redirection)) {

                        throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(theUrl)+"' HTTPStatus = "+status+" redirect to blank URL.");

                    }

                    try {

                        theUrl = new URL(redirection);

                    } catch (Exception ex) {

                        throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(theUrl)+"' HTTPStatus = "+status+" redirect to invalid URL "+redirection);

                    }

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

                    // 3xx redirection

                    throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(theUrl)+"' 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(theUrl);

                    }

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

                    // 4xx client errors

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

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

                    // 5xx server errors

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

                } else {

                    //Unknown

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

                }

            }

            throw new IOExceptionWithStatus(status, "Can't call method "+method+" "+Objects.toString(theUrl)+"' 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(theUrl)+"' last status " + status, ex);

        }

    }

    @Override

    public void run() {

        try {

            send(this.method, this.contenttype, this.data);

            postdownload();

        } catch (Exception e) {

            exception(e);

        }

    }

    private Executor getExecutorUI()  {

//        return this.downloader.getExecutorUI();

        return null;

    }

}