Application: gvSIG desktop

package org.gvsig.compat.se.net;

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

import java.io.BufferedOutputStream;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.net.ConnectException;

import java.net.HttpURLConnection;

import java.net.URL;

import java.net.UnknownHostException;

import java.security.KeyManagementException;

import java.security.NoSuchAlgorithmException;

import java.util.Hashtable;

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.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.compat.net.ICancellable;

/**

 * Clase con m?todos de utilidad en el protocolo WMS

 *

 * @authors Laura D?az, jaume dominguez faus

 */

public class SEDownloader implements org.gvsig.compat.net.Downloader{

    String                  characters;

        boolean                 canceled;

        final long              latency    = 500;

        private static int      count      = 0;

        private static Logger   LOG     = LoggerFactory.getLogger(SEDownloader.class);

        /**

         * Used to cancel a group of files

         * <b>key</b>: Group id, <b>value</b>: Boolean (true if

         * the group has to be canceled. Otherwise it is

         * false)

         */

        Hashtable canceledGroup = new Hashtable();

        /**

         * <b>key</b>: URL, <b>value</b>: path to the downloaded file.

         */

        Hashtable downloadedFiles;

        Exception downloadException;

        final String tempDirectoryPath = System.getProperty("java.io.tmpdir")+"/tmp-andami";

        public SEDownloader() {

        super();  

                characters = "";

                for (int j = 32; j<=127; j++){

                        characters += (char) j;

                }

                characters += "?????????????????????????????????????????????????\n\r\f\t??";

        }

        /**

         * Return the content of a file that has been created 

         * from a URL using the HTTP GET protocol

         * @param url

         * The URL

         * @return

         * File containing this URL's content or null if no file was found.

         */

        private File getPreviousDownloadedURL(URL url){

                return getPreviousDownloaded(url);

        }

        /**

         * Return the content of a file that has been created 

         * from a URL using the HTTP POST protocol

         * @param url

         * The URL

         * @param data

         * The data to send on the query

         * @return

         * File containing this URL's content or null if no file was found.

         */

        private File getPreviousDownloadedURL(URL url, String data) {

                if(data == null)

                        return getPreviousDownloaded(url);

                return getPreviousDownloaded(url + data);

        }

        /**

         * Returns the content of a URL as a file from the file system.<br>

         * <p>

         * If the URL has been already downloaded in this session and notified

         * to the system using the static <b>Utilities.addDownloadedURL(URL)</b>

         * method, it can be restored faster from the file system avoiding to

         * download it again.

         * </p>

         * @param url

         * @return File containing this URL's content or null if no file was found.

         */

        private File getPreviousDownloaded(Object object) {

                File f = null;

                if (downloadedFiles != null && downloadedFiles.containsKey(object)) {

                        String filePath = (String) downloadedFiles.get(object);

                        f = new File(filePath);

                        if (!f.exists())

                                return null;

                }

                return f;

        }

        /**

         * Adds an URL to the table of downloaded files for further uses. If the URL

         * already exists in the table its filePath value is updated to the new one and

         * the old file itself is removed from the file system.

         *

         * @param url

         * @param filePath

         */

        void addDownloadedURL(URL url, String filePath) {

                if (downloadedFiles == null)

                        downloadedFiles = new Hashtable();

                String fileName = (String) downloadedFiles.put(url, filePath);

                //JMV: No se puede eliminar el anterior porque puede que alguien lo

                // este usando

                /*

        if (fileName!=null){

            File f = new File(fileName);

            if (f.exists())

                f.delete();

        }

                 */

        }

        /**

         * Downloads an URL into a temporary file that is removed the next time the

         * tempFileManager class is called, which means the next time gvSIG is launched.

         *

         * @param url

         * @param name

         * @return

         * @throws IOException

         * @throws ServerErrorResponseException

         * @throws ConnectException

         * @throws UnknownHostException

         */

        public synchronized File downloadFile(URL url, String name, ICancellable cancel) throws IOException,ConnectException, UnknownHostException {

                File f = null;

                if ((f = getPreviousDownloadedURL(url)) == null) {

                        File tempDirectory = new File(tempDirectoryPath);

                        if (!tempDirectory.exists())

                                tempDirectory.mkdir();

                        f = new File(calculateFileName(name));

                        if (cancel == null) {

                                cancel = new ICancellable() {

                                        public boolean isCanceled() {

                                                return false;

                                        }

                                        public Object getID(){

                                                return SEDownloader.class.getName();

                                        }

                                };

                        }

                        Monitor monitorObj = new Monitor(this, cancel);

                        Thread downloader = new Thread(new Downloader(this, url, f, cancel.getID()));

                        Thread monitor = new Thread(monitorObj);

                        monitor.start();

                        downloader.start();

                        while(!getCanceled(cancel.getID()) && downloader.isAlive()) {

                                try {

                                        Thread.sleep(latency);

                                } catch (InterruptedException e) {

                                        LOG.error("Error", e);

                                }

                        }

                        try {

                                monitorObj.setFinish(true);

                                monitor.join();

                                downloader.join();

                        } catch (InterruptedException e1) {

                                LOG.warn(e1.getMessage());

                        }

                        downloader = null;

                        monitor = null;

                        if (getCanceled(cancel.getID()))

                                return null;

                        downloader = null;

                        monitor = null;

                        if (this.downloadException != null) {

                                Exception e = this.downloadException;

                                if (e instanceof FileNotFoundException)

                                        throw (IOException) e;

                                else if (e instanceof IOException)

                                        throw (IOException) e;

                                else if (e instanceof ConnectException)

                                        throw (ConnectException) e;

                                else if (e instanceof UnknownHostException)

                                        throw (UnknownHostException) e;

                        }

                } else {

                    LOG.info(url.toString() + " cached at '" + f.getAbsolutePath() + "'");

                }

                return f;

        }

        private String calculateFileName(String name) {

                count ++;

                int index = name.lastIndexOf(".");

                if (index > 0){

                        return tempDirectoryPath + "/" + name.substring(0,index) + System.currentTimeMillis() + count + 

                                name.substring(index, name.length());

                }

                return tempDirectoryPath + "/" + name + System.currentTimeMillis() + count;

        }

        /**

         * Downloads a URL using the HTTP Post protocol

         * @param url

         * The server URL

         * @param data

         * The data to send in the request

         * @param name

         * A common name for all the retrieved files

         * @param cancel

         * Used to cancel the downloads

         * @return

         * The retrieved file

         * @throws IOException

         * @throws ConnectException

         * @throws UnknownHostException

         */

        public synchronized File downloadFile(URL url, String data, String name, ICancellable cancel) throws IOException,ConnectException, UnknownHostException{

                File f = null;

                if ((f = getPreviousDownloadedURL(url,data)) == null) {

                        File tempDirectory = new File(tempDirectoryPath);

                        if (!tempDirectory.exists())

                                tempDirectory.mkdir();

                        f = new File(calculateFileName(name));

                        if (cancel == null) {

                                cancel = new ICancellable() {

                                        public boolean isCanceled() {

                                                return false;

                                        }

                                        public Object getID(){

                                                return SEDownloader.class.getName();

                                        }

                                };

                        }

                        Monitor monitorObj = new Monitor(this, cancel);

                        Thread downloader = new Thread(new Downloader(this, url, data, f, cancel.getID()));

                        Thread monitor = new Thread(monitorObj);

                        monitor.start();

                        downloader.start();

                        while(!getCanceled(cancel.getID()) && downloader.isAlive()) {

                                try {

                                        Thread.sleep(latency);

                                } catch (InterruptedException e) {

                                        LOG.error("Error", e);

                                }

                        }

                        try {

                                monitorObj.setFinish(true);

                                monitor.join();

                                downloader.join();

                        } catch (InterruptedException e1) {

                                LOG.warn(e1.getMessage());

                        }

                        downloader = null;

                        monitor = null;

                        if (getCanceled(cancel.getID()))

                                return null;

                        if (this.downloadException!=null) {

                                Exception e = this.downloadException;

                                if (e instanceof FileNotFoundException)

                                        throw (IOException) e;

                                else if (e instanceof IOException)

                                        throw (IOException) e;

                                else if (e instanceof ConnectException)

                                        throw (ConnectException) e;

                                else if (e instanceof UnknownHostException)

                                        throw (UnknownHostException) e;

                        }

                } else {

                        LOG.info(url.toString() + " cached at '" + f.getAbsolutePath() + "'");

                }

                return f;

        }

        /**

         * Try if a group of downloads has been canceled

         * @param groupId

         * Group id

         * @return

         * If the group has been canceled

         */

        protected boolean getCanceled(Object groupId) {

                Object obj = canceledGroup.get(groupId);

                if (obj != null) {

                        return ((Boolean)obj).booleanValue();

                }

                return false;

        }

        /**

         * Cancel a group of downloads

         * @param groupId

         * Group id

         * @param isCanceled

         * if the group has to be canceled

         */

        protected void setCanceled(Object groupId, boolean isCanceled) {

                if (groupId == null) {

                        groupId = SEDownloader.class.getName();

                }

                canceledGroup.put(groupId,new Boolean(isCanceled));

        }

        /**

         * Cleans every temporal file previously downloaded.

         */

        public void cleanUpTempFiles() {

                try{

                        File tempDirectory = new File(tempDirectoryPath);

                        File[] files = tempDirectory.listFiles();

                        if (files!=null) {

                                for (int i = 0; i < files.length; i++) {

                                        // s?lo por si en un futuro se necesitan crear directorios temporales

                                        if (files[i].isDirectory())        deleteDirectory(files[i]);

                                        files[i].delete();

                                }

                        }

                        tempDirectory.delete();

                } catch (Exception e) {        }

        }

        /**

         * Recursive directory delete.

         * @param f

         */

        private void deleteDirectory(File f) {

                File[] files = f.listFiles();

                for (int i = 0; i < files.length; i++) {

                        if (files[i].isDirectory()) 

                                deleteDirectory(files[i]);

                        files[i].delete();

                }

        }

        /**

         * Remove an URL from the system cache. The file will remain in the file

         * system for further eventual uses.

         * @param request

         */

        public void removeURL(URL url) {

                if (downloadedFiles != null && downloadedFiles.containsKey(url))

                        downloadedFiles.remove(url);

        }

        /**

         * Remove an URL from the system cache. The file will remain in the file

         * system for further eventual uses.

         * @param request

         */

        public void removeURL(Object url) {

                if (downloadedFiles != null && downloadedFiles.containsKey(url))

                        downloadedFiles.remove(url);

        }

}

final class Monitor implements Runnable {

        ICancellable c;

        private volatile boolean finish = false;

        SEDownloader downloader;

        private static Logger LOG = LoggerFactory.getLogger(Monitor.class);

        public Monitor(SEDownloader downloader, ICancellable cancel) {

            downloader.setCanceled(cancel.getID(),false);

                this.c = cancel;

                this.downloader = downloader;

        }

        public void run() {

                while (!c.isCanceled() && !getFinish()) {

                        try {

                                Thread.sleep(downloader.latency);

                        } catch (InterruptedException e) {

                                LOG.error("Error", e);

                        }

                }

                /*  WARNING!! This works because only one download is being processed at once.

                 *  You could prefer to start several transfers simultaneously. If so, you

                 *  should consideer using a non-static variable such is Utilities.canceled to

                 *  control when and which transfer in particular has been canceled.

                 *

                 *  The feature of transfer several files is at the moment under study. We are

                 *  planning to add an intelligent system that will give you a lot of services

                 *  and ease-of-use. So, we encourage you to wait for it instead of write your

                 *  own code.

                 */

                if(c.isCanceled())

                        downloader.setCanceled(c.getID(), true);

        }

        public synchronized void setFinish(boolean value) { 

                finish = value; 

        }

        public synchronized boolean getFinish() { 

                return finish; 

        }

}

final class Downloader implements Runnable {

        private URL url                    = null;

        private File dstFile               = null;

        private Object groupID             = null;

        private String data                = null;

        private SEDownloader downloader    = null;

        private static Logger LOG       = LoggerFactory.getLogger(Downloader.class);

        public Downloader(SEDownloader downloader, URL url, File dstFile, Object groupID) {

                this.url = url;

                this.dstFile = dstFile;

                this.groupID = groupID;

                this.downloader = downloader;

                downloader.downloadException = null;

        }

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

                this.url = url;

                this.data = data;

                this.dstFile = dstFile;

                this.groupID = groupID;        

                this.downloader = downloader;

                downloader.downloadException = null;

        }

        public void run() {

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

                if (data != null){

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

                }

                // 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);

                DataOutputStream dos;

                try {

                        DataInputStream is;

                        OutputStreamWriter os = null;

                        HttpURLConnection connection = null;

                        //If the used protocol is HTTPS

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

                                disableHttsValidation();

                        }

                        connection = (HttpURLConnection)url.openConnection();

                        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();        

                                is = new DataInputStream(connection.getInputStream());

                        }else{

                                is = new DataInputStream(url.openStream());

                        }

                        dos = new DataOutputStream( new BufferedOutputStream(new FileOutputStream(dstFile)));

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

                        long readed = 0;

                        for (int i = is.read(buffer); !downloader.getCanceled(groupID) && i>0; i = is.read(buffer)){

                                dos.write(buffer, 0, i);

                                readed += i;

                        }

                        if(os != null) {

                                os.close();

                        }

                        dos.close();

                        is.close();

                        is = null;

                        dos = null;

                        if (downloader.getCanceled(groupID)) {

                                LOG.info("[RemoteServices] '" + url + "' CANCELED.");

                                dstFile.delete();

                                dstFile = null;

                        } else {

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

                        }

                } catch (Exception e) {

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

                        downloader.downloadException = e;

                }                

        }

        /**

         * This method disables the Https certificate validation.

         * @throws KeyManagementException

         * @throws NoSuchAlgorithmException

         */

        private 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());

        }

}