/branches/v2_0_0_prep/libraries/libRemoteServices/src/org/gvsig/remoteclient/utils/Utilities.java - Diff - | gvSIG desktop 1 - gvSIG

Revision 33738 branches/v2_0_0_prep/libraries/libRemoteServices/src/org/gvsig/remoteclient/utils/Utilities.java

      */
     import java.io.BufferedOutputStream;
     import java.io.DataInputStream;
     import java.io.DataOutputStream;
     import java.io.File;
     import java.io.FileNotFoundException;
-...
     import java.io.IOException;
     import java.io.InputStream;
     import java.io.OutputStream;
     import java.io.OutputStreamWriter;
     import java.net.ConnectException;
     import java.net.HttpURLConnection;
     import java.net.URL;
     import java.net.UnknownHostException;
     import java.rmi.NoSuchObjectException;
     import java.security.KeyManagementException;
     import java.security.NoSuchAlgorithmException;
     import java.util.Hashtable;
     import java.util.StringTokenizer;
     import java.util.Vector;
     import javax.net.ssl.HttpsURLConnection;
     import javax.net.ssl.SSLContext;
     import javax.net.ssl.TrustManager;
     import javax.net.ssl.X509TrustManager;
     import org.gvsig.compat.CompatLocator;
     import org.gvsig.compat.net.Downloader;
     import org.gvsig.remoteclient.wms.ICancellable;
-...
      * @authors Laura D?az, jaume dominguez faus
      */
     public class Utilities {
     	private static String characters;
     	private static final Downloader downloader = CompatLocator.getDownloader();
         private static String characters;
     	static boolean canceled;
     	static final long latency = 500;
     	/**
-...
     		try {
     			index2 = findBeginIndex(bytes, startTag);
     		} catch (NoSuchObjectException e) {
     		} catch (Exception e) {
     			return bytes;
+    		}
-...
+    	 *
     	 * @return ?ndice donde empieza el tag raiz
+    	 *
     	 * @throws NoSuchObjectException Si no se encuentra el tag
     	 * @throws Exception Si no se encuentra el tag
     	 */
     	private static int findBeginIndex(byte[] bytes, String tagRaiz)
     	throws NoSuchObjectException {
     	throws Exception {
     		try {
     			int nodo = 0;
     			int ret = -1;
-...
     				i++;
+    			}
     		} catch (Exception e) {
     			throw new NoSuchObjectException("No se pudo parsear el xml");
     			throw new Exception("No se pudo parsear el xml", e);
+    		}
+    	}
-...
+    		}
     		return s;
+    	}
     	/**
     	 * 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 static 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 static File getPreviousDownloadedURL(URL url, String data){
     		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 static 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
     	 */
     	static 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.
+    	 *
-...
     	 * @throws UnknownHostException
     	 */
     	public static 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 Utilities.class.getName();
+    					}
     				};
+    			}
     			Thread downloader = new Thread(new Downloader(url, f, cancel.getID()));
     			Thread monitor = new Thread(new Monitor(cancel));
     			monitor.start();
     			downloader.start();
     			while(!getCanceled(cancel.getID()) && downloader.isAlive()) {
     				try {
     					Thread.sleep(latency);
     				} catch (InterruptedException e) {
     					// TODO Auto-generated catch block
     					e.printStackTrace();
+    				}
+    			}
     			if (getCanceled(cancel.getID()))
     				return null;
     			downloader = null;
     			monitor = null;
     			if (Utilities.downloadException!=null) {
     				Exception e = Utilities.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 {
     			System.out.println(url.toString()+" cached at '"+f.getAbsolutePath()+"'");
+    		}
     		return f;
     	    return downloader.downloadFile(url, name, new CancellableAdapter(cancel));
+    	}
     	private static String calculateFileName(String name){
-...
     	 * @throws UnknownHostException
     	 */
     	public static 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 Utilities.class.getName();
+    					}
     				};
+    			}
     			Thread downloader = new Thread(new Downloader(url, data, f, cancel.getID()));
     			Thread monitor = new Thread(new Monitor(cancel));
     			monitor.start();
     			downloader.start();
     			while(!getCanceled(cancel.getID()) && downloader.isAlive()) {
     				try {
     					Thread.sleep(latency);
     				} catch (InterruptedException e) {
     					// TODO Auto-generated catch block
     					e.printStackTrace();
+    				}
+    			}
     			if (getCanceled(cancel.getID()))
     				return null;
     			downloader = null;
     			monitor = null;
     			if (Utilities.downloadException!=null) {
     				Exception e = Utilities.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 {
     			System.out.println(url.toString()+" cached at '"+f.getAbsolutePath()+"'");
+    		}
     		return f;
     	    return downloader.downloadFile(url, data, name, new CancellableAdapter(cancel));
+    	}
     	/**
     	 * Try if a group of downloads has been canceled
     	 * @param groupId
     	 * Group id
     	 * @return
     	 * If the group has been canceled
     	 */
     	protected static 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 static void setCanceled(Object groupId, boolean isCanceled){
     		if (groupId == null){
     			groupId = Utilities.class.getName();
+    		}
     		canceledGroup.put(groupId,new Boolean(isCanceled));
+    	}
     	/**
     	 * Cleans every temporal file previously downloaded.
     	 */
     	public static 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) {	}
     		downloader.cleanUpTempFiles();
+    	}
     	/**
     	 * Recursive directory delete.
     	 * @param f
     	 */
     	private static 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 static void removeURL(URL url) {
     		if (downloadedFiles != null && downloadedFiles.containsKey(url))
     			downloadedFiles.remove(url);
     		downloader.removeURL(url);
+    	}
     	/**
-...
     	 * @param request
     	 */
     	public static void removeURL(Object url) {
     		if (downloadedFiles != null && downloadedFiles.containsKey(url))
     			downloadedFiles.remove(url);
     	    downloader.removeURL(url);
+    	}
+    }
     	/**
     	 * This class has to be deleted when all the classes uses the ICancellable
     	 * method from libCompat
     	 * @author gvSIG Team
     	 * @version $Id$
+    	 *
     	 */
     	private static class CancellableAdapter implements org.gvsig.compat.net.ICancellable{
     	    private ICancellable cancellable = null;
     final class Monitor implements Runnable {
     	ICancellable c;
     	public Monitor(ICancellable cancel) {
     		Utilities.setCanceled(cancel.getID(),false);
     		this.c = cancel;
+    	}
     	public void run() {
     		while (!c.isCanceled()) {
     			try {
     				Thread.sleep(Utilities.latency);
     			} catch (InterruptedException e) {
     				e.printStackTrace();
+    			}
+    		}
             public CancellableAdapter(
                 org.gvsig.remoteclient.wms.ICancellable cancellable) {
                 super();
                 this.cancellable = cancellable;
+            }
     		/*  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.
     		 */
             public Object getID() {
                 return cancellable.getID();
+            }
     		Utilities.setCanceled(c.getID(),true);
             public boolean isCanceled() {
                 return cancellable.isCanceled();
+            }
+    	}
+    }
     final class Downloader implements Runnable {
     	private URL url;
     	private File dstFile;
     	private Object groupID = null;
     	private String data = null;
     	public Downloader(URL url, File dstFile, Object groupID) {
     		this.url = url;
     		this.dstFile = dstFile;
     		this.groupID = groupID;
     		Utilities.downloadException = null;
+    	}
     	public Downloader(URL url, String data, File dstFile, Object groupID) {
     		this.url = url;
     		this.data = data;
     		this.dstFile = dstFile;
     		this.groupID = groupID;
     		Utilities.downloadException = null;
+    	}
     	public void run() {
     		System.out.println("downloading '"+url.toString()+"' to: "+dstFile.getAbsolutePath());
     		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();
     			//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); !Utilities.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 (Utilities.getCanceled(groupID)) {
     				System.err.println("[RemoteServices] '"+url+"' CANCELED.");
     				dstFile.delete();
     				dstFile= null;
     			} else {
     				Utilities.addDownloadedURL(url, dstFile.getAbsolutePath());
+    			}
     		} catch (Exception e) {
     			e.printStackTrace();
     			Utilities.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());
+    	}
+    }

Also available in: Unified diff