Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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 3 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., 51

 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

 */

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

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.net.ConnectException;

import java.net.URI;

import java.net.URL;

import java.net.UnknownHostException;

import java.util.HashMap;

import java.util.Map;

import org.apache.commons.io.FileUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.compat.net.ICancellable;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.folders.FoldersManager;

/**

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

 *

 */

public class SEDownloader implements Downloader {

//    private boolean canceled;

    private final long latency = 500;

    private static final 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)

     */

    private final Map<Object,Boolean> canceledGroup = new HashMap();

    /**

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

     */

    private Map<Object,String> cachedURItoFile;

    private Exception downloadException;

    public SEDownloader() {

        super();

    }

    /**

     * 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.toString() + 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 theurl

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

     */

    private File getPreviousDownloaded(Object theurl) {

        File f = null;

        Object thekey;

        try {

            if (theurl instanceof URL) {

                thekey = ((URL) theurl).toURI();

            } else {

                thekey = theurl;

            }

        } catch (Exception e) {

            LOG.info("Warning: did not check url: " + theurl, e);

            return null;

        }

        if (cachedURItoFile != null && cachedURItoFile.containsKey(thekey)) {

            String filePath = (String) cachedURItoFile.get(thekey);

            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

     */

    @Override

    public void addDownloadedURL(URL url, String filePath) {

        if (cachedURItoFile == null) {

            cachedURItoFile = new HashMap();

        }

        URI theuri;

        try {

            theuri = url.toURI();

        } catch (Exception e) {

            LOG.info("Warning: did not cache bad url: " + url, e);

            return;

        }

        String fileName = (String) cachedURItoFile.put(theuri, 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 ConnectException

     * @throws UnknownHostException

     */

    @Override

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

        File f;

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

            f = getUniqueTemporaryFile(name);

            if (cancel == null) {

                cancel = new ICancellable() {

                    @Override

                    public boolean isCanceled() {

                        return false;

                    }

                    @Override

                    public Object getID() {

                        return SEDownloader.class.getName();

                    }

                };

            }

            SEMonitor monitorObj = new SEMonitor(this, cancel);

            Thread downloader = new Thread(createDownloaderTask(this, url, null, f, cancel.getID().getClass(),-1));

            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;

    }

    /**

     * 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

     */

    @Override

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

        return downloadFile(url, data, name, cancel, -1);

    }

    @Override

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

        File f;

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

            f = getUniqueTemporaryFile(name);

            if (cancel == null) {

                cancel = new ICancellable() {

                    @Override

                    public boolean isCanceled() {

                        return false;

                    }

                    @Override

                    public Object getID() {

                        return SEDownloader.class.getName();

                    }

                };

            }

            SEMonitor monitorObj = new SEMonitor(this, cancel);

            Thread downloader = new Thread(

                    createDownloaderTask(this, url, data, f, cancel.getID(),maxbytes)

            );

            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

     */

    @Override

    public boolean getCanceled(Object groupId) {

        Boolean obj = canceledGroup.get(groupId);

        if (obj != null) {

            return obj;

        }

        return false;

    }

    /**

     * Cancel a group of downloads

     *

     * @param groupId Group id

     * @param isCanceled if the group has to be canceled

     */

    @Override

    public void setCanceled(Object groupId, boolean isCanceled) {

        if (groupId == null) {

            groupId = SEDownloader.class.getName();

        }

        canceledGroup.put(groupId, isCanceled);

    }

    /**

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

     * system for further eventual uses.

     *

     * @param url

     */

    @Override

    public void removeURL(URL url) {

        URI theuri = null;

        try {

            theuri = url.toURI();

        } catch (Exception e) {

            LOG.info("Warning: did not remove bad url: " + url, e);

            return;

        }

        if (cachedURItoFile != null && cachedURItoFile.containsKey(theuri)) {

            cachedURItoFile.remove(theuri);

        }

    }

    /**

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

     * system for further eventual uses.

     *

     * @param url

     */

    @Override

    public void removeURL(Object url) {

        if (cachedURItoFile != null && cachedURItoFile.containsKey(url)) {

            cachedURItoFile.remove(url);

        }

    }

    @Override

    public void setDownloadException(Exception exception) {

        this.downloadException = exception;

    }

    @Override

    public long getLatency() {

        return this.latency;

    }

    protected Runnable createDownloaderTask(Downloader downloader, URL url, String data, File target, Object groupID,int maxbytes){

        SEDownloaderTask t = new SEDownloaderTask(downloader, url, data, target, groupID);

        t.setMaxbytes(maxbytes);

        return t;

    }

    /**

     * Cleans every temporal file previously downloaded.

     */

    @Override

    public void cleanUpTempFiles() {

        FoldersManager foldersManager = ToolsLocator.getFoldersManager();

        File folder = foldersManager.getTemporaryFile("downloader");

        try {

            FileUtils.cleanDirectory(folder);

        } catch (IOException ex) {

            LOG.warn("Can't clean folder '"+folder.getAbsolutePath()+"'.",ex);

        }

    }

    private File getUniqueTemporaryFile(String name) {

        FoldersManager foldersManager = ToolsLocator.getFoldersManager();

        File folder = foldersManager.getTemporaryFile("downloader");

        if( !folder.exists() ) {

            folder.mkdirs();

        }

        File f = foldersManager.getUniqueTemporaryFile("downloader",name);

        return f;

    }

}