Application: gvSIG desktop

@SuppressWarnings("UseSpecificCatch")

final class SEDownloaderTask 

        extends AbstractSEDownloaderTask

        implements Runnable {

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

    @Override

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

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

        int timeout = this.getTimeout();

            download(connection.getInputStream());

            postdownload();

            exception(e);

package org.gvsig.compat.se.net.downloader.se;

import java.io.BufferedOutputStream;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStreamWriter;

import java.net.HttpURLConnection;

import java.net.URL;

import java.security.KeyManagementException;

import java.security.NoSuchAlgorithmException;

import java.util.prefs.Preferences;

import javax.net.ssl.HttpsURLConnection;

import javax.net.ssl.SSLContext;

import javax.net.ssl.TrustManager;

import javax.net.ssl.X509TrustManager;

import org.apache.commons.io.IOUtils;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public abstract class AbstractSEDownloaderTask implements Runnable {

    protected static final Logger LOGGER = LoggerFactory.getLogger(AbstractSEDownloaderTask.class);

    protected final URL url;

    protected final File dstFile;

    protected final Object groupID;

    protected final String data;

    protected final Downloader downloader;

    private int maxbytes;

    public AbstractSEDownloaderTask(Downloader downloader, URL url, String data, File dstFile, Object groupID) {

        this.url = url;

        this.data = data;

        this.dstFile = dstFile;

        this.groupID = groupID;

        this.downloader = downloader;

        this.maxbytes = -1;

        downloader.setDownloadException(null);

    }

    public void setMaxbytes(int maxbytes) {

        this.maxbytes = maxbytes;

    }

    public int getMaxbytes() {

        return maxbytes;

    }

    protected void download(InputStream is) throws IOException {

        DataOutputStream dos = null;

        DataInputStream dis = null;

        FileOutputStream fos = null;

        BufferedOutputStream bos = null;

        try {

            fos = new FileOutputStream(dstFile);

            if( is != null ) {

                bos = new BufferedOutputStream(fos);

                dos = new DataOutputStream(bos);

                dis = new DataInputStream(is);

                byte[] buffer = new byte[1024 * 4];

                long readed = 0;

                for (int i = dis.read(buffer); !isCanceled() && i > 0; i = dis.read(buffer)) {

                    dos.write(buffer, 0, i);

                    readed += i;

                    if( maxbytes>0 && readed>maxbytes ) {

                        break;

                    }

                }

            }

        } finally {

            IOUtils.closeQuietly(dos);

            IOUtils.closeQuietly(bos);

            IOUtils.closeQuietly(fos);

            IOUtils.closeQuietly(dis);

        }

    }

    protected boolean isCanceled() {

        return downloader.getCanceled(groupID);

    }

    protected int getTimeout() {

        // getting timeout from preferences in milliseconds.

        Preferences prefs = Preferences.userRoot().node("gvsig.downloader");

        // by default 1 minute (60000 milliseconds.

        int timeout = prefs.getInt("timeout", 60000);

        return timeout;

    }

    protected void postdownload() {

        if (isCanceled()) {

            LOGGER.info("[Downloader] '" + url + "' CANCELED.");

            dstFile.delete();

//            dstFile = null;

        } else {

            downloader.addDownloadedURL(url, dstFile.getAbsolutePath());

        }

    }

    protected void exception(Exception e) {

        LOGGER.info("Error downloading", e);

        downloader.setDownloadException(e);

    }

    /**

     * This method disables the Https certificate validation.

     *

     * @throws KeyManagementException

     * @throws NoSuchAlgorithmException

     */

    protected void disableHttsValidation() throws KeyManagementException, NoSuchAlgorithmException {

        // Create a trust manager that does not validate certificate chains

        TrustManager[] trustAllCerts = new TrustManager[]{

            new X509TrustManager() {

                public java.security.cert.X509Certificate[] getAcceptedIssuers() {

                    return null;

                }

                public void checkClientTrusted(

                        java.security.cert.X509Certificate[] certs, String authType) {

                }

                public void checkServerTrusted(

                        java.security.cert.X509Certificate[] certs, String authType) {

                }

            }

        };

        // Install the all-trusting trust manager

        SSLContext sc = SSLContext.getInstance("SSL");

        sc.init(null, trustAllCerts, new java.security.SecureRandom());

        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());

    }

}