/ - Diff - Application: gvSIG desktop - gvSIG

     /**
      * 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.remoteclient.taskplanning;
     /**
      * Interface implemented by those tasks that can be background-executed,
      * cancelled or any other thing.
+     *
      * @author jaume dominguez faus - jaume.dominguez@iver.es
      */
     public interface IRunnableTask {
     	/**
     	 * Executes this task's operations.
     	 */
     	public void execute();
     	/**
     	 * Cancels the current execution, if any, of this task. Should have no
     	 * effect if the task is not executing anything.
     	 */
     	public void cancel();
     	/**
     	 * Tells if the task is on execution.
     	 * @return true if the task is busy, false otherwise.
     	 */
     	public boolean isRunning();
     	/**
     	 * Returns the timeout set to this task in milliseconds
     	 * @return the amount of milliseconds to wait until the task
     	 * 		   will be considered as unsuccessful, or 0 or less to
     	 * 		   say that task can wait forever.
     	 */
     	public long getTaskTimeout();
+    }

     /**
      * 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.remoteclient.taskplanning;
     /**
      * A simple FIFO task planner. The tasks returned by this planner are executed
      * enterely. It does not issue another task until the current is finished.
      * @author jaume
+     *
      */
     public class FIFOTaskPlanner implements ITaskPlanner {
     	IQueue queue;
     	/**
     	 * Creates a new instance of FIFOTaskPlanner that will work against the
     	 * queue passed as paramenter
     	 * @param queue, the IQueue to be planned
     	 */
     	public FIFOTaskPlanner(IQueue queue) {
     		this.queue = queue;
+    	}
     	public IRunnableTask nextTask() {
     		synchronized (this) {
     			return (IRunnableTask) queue.getTasks().remove(0);
+    		}
+    	}
     	/**
     	 * FIFO plans have no previous tasks so, null is always returned.
     	 */
     	public IRunnableTask previousTask() {
     		return null;
+    	}
+    }

     /**
      * 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.remoteclient.taskplanning;
     /**
      * <p>
      * ITaskPlanner provides an interface to program your own task planning. It gives
      * you operations for pick a task from the queue according on the criteria that
      * you designed.<br>
      * </p>
      * <p>
      * The simplest implementation of ITaskPlanner would be a FIFO task planner (see
      * FIFOTaskPlanner.java) which takes jobs from a task queue in the same order
      * they were put. But any kind of planner is possible (SJF, LIFO, RoundRobin, etc.).
      * </p>
      * @author jaume dominguez faus - jaume.dominguez@iver.es
+     *
      */
     public interface ITaskPlanner {
     	/**
     	 * Takes the next task to be executed.
     	 * @return IRunnableTask representing the next task to be executed
     	 */
     	public IRunnableTask nextTask();
     	/**
     	 * Takes the previous executed task. Notice that it may or may not have
     	 * sense for specific implementations. For example, in a FIFO-like planner,
     	 * the task is taken from the queue, executed until it is finished and
     	 * removed from the queue. So, there is no previous task.
+    	 *
     	 * @return IRunnableTask representing the previous executed task, or null
     	 * if none.
     	 * @deprecated (probably this is unuseful and i'll remove it)
     	 */
     	public IRunnableTask previousTask();
+    }

     /**
      * 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.remoteclient.taskplanning;
     import java.util.Vector;
     /**
      *  <p>
      *  You should write your own concrete Queue implementation to hold the tasks in
      *  a specific kind of queue.<br>
      *  </p>
      *  <p>
      *  Following the contract, you should also write a task planner that does what
      *  you desire. Task planners are a concrete class of the ITaskPlanner that would
      *  plannify which is the next, the previous,.. task to be done. However, if
      *  you don't want to write anything special, just guess a simple FIFO queue<br>
      *  </p>
+     *
      *  @author jaume dominguez faus - jaume.dominguez@iver.es
      *  @see ITaskPlanner
      */
     public interface IQueue {
     	/**
     	 * Adds a new task to the queue. The place where the new task will be put its
     	 * left to the concrete implementation of this interface.
     	 * @param IRunnableTask task
     	 */
     	IRunnableTask put(IRunnableTask task);
     	/**
     	 * Returns the next task by calling the task planner's nextTask() method.
     	 * @return IRunnableTask with the next task to be executed.
     	 */
     	IRunnableTask take();
     	/**
     	 * Returns true if the Queue has no (more) jobs to do.
     	 * @return
     	 */
     	boolean isEmpty();
     	/**
     	 * Returns the task planner currently defined by this queue.
     	 * @return ITaskPlanner
     	 */
     	ITaskPlanner getTaskPlanner();
     	/**
     	 * Sets the TaskPlanner that will decide which of the tasks in the queue will
     	 * be executed next. A null value should represent a FIFO planner.
     	 * @param planner
     	 */
     	void setTaskPlanner(ITaskPlanner planner);
     	/**
     	 * Causes the execution of this queue to be paused. The task currently in execution
     	 * finishes and after it the planner will not issue more tasks until resume() is
     	 * invoked.
     	 */
     	void pause();
     	/**
     	 * Causes the execution of this queue to be resumed. The execution will continue
     	 * with the next task issued by the planner. It has no effect if the queue was not
     	 * paused yet.
     	 */
     	void resume();
     	/**
     	 * Returns the set of tasks in a Vector (thread-safe).
     	 * @return Vector containing the tasks in this queue.
     	 */
     	Vector getTasks();
+    }

     /**
      * 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.remoteclient.taskplanning.retrieving;
     import java.io.File;
     import java.net.MalformedURLException;
     import java.util.Hashtable;
     import java.util.TreeMap;
     import org.gvsig.remoteclient.taskplanning.IQueue;
     /**
      * pa administrar les tasques (la hist?ria aquella
      *  de que hi haja una cola per a cada servidor)
      * @author Luis W. Sevilla (sevilla_lui@gva.es)
      */
     public class RequestManager {
     	private boolean debug = true;
     	private static RequestManager instance;
     	private TreeMap serversTable = new TreeMap();
     	private RequestManager() {} // Avoid public instantiation
     	public static RequestManager getInstance() {
     		if (instance == null)
     			instance = new RequestManager();
     		return instance;
+    	}
     	public URLRetrieveTask addURLRequest(URLRequest request, RetrieveListener listener) {
     		try {
     			// TODO canviar per a quetorne el Request antic, que la request guarde el
     			// seu estat aix? com la llista de listeners
     			File f = getPreviousDownloadedURLRequest(request);
     			if (f!=null) {
     				// The file was already requested and it is in the cache or
     				// the download is in process
     				// Overwrite the file name with the file in the cache's one.
     				request.setFileName(f.getAbsolutePath());
     				System.out.println(request.getUrl()+" is cached at '"+f.getAbsolutePath()+"'");
     				// get this server's task queue
     				RetrieveQueue serverQueue = (RetrieveQueue) getQueue(request.getHost());
     				// Look up the previous cached jobs
     				URLRetrieveTask workingTask = serverQueue.getURLPreviousRequest(request);
     				if (workingTask == null) {
     					// Task already done. Notify listener
     					if (debug)
     						System.err.println("done job found: "+request.getUrl());
     					RetrieveEvent event = new RetrieveEvent();
     					event.setType(RetrieveEvent.REQUEST_FINISHED);
     					listener.transferEventReceived(event);
     				} else {
     					// The task is working yet, will register the listener
     					// TODO no va b?... perqu? la cola va buidant-se molt r?pidament
     					// per a fer que vaja tamb? hi hauria que registrar en cache
     					// lo que s'est? baixant al principi de l'execute();
     					if (debug)
     						System.err.println("working job found: "+request.getUrl());
     					workingTask.addRetrieveListener(listener);
+    				}
     			} else {
     				// Pick an unrepeatable fileName
     				String host = request.getHost();
     				String fileName = request.getFileName();
     				File tempDir = new File(tempDirectoryPath);
     				if (!tempDir.exists())
     					tempDir.mkdir();
     				String fileNamePrefix = tempDirectoryPath +
     											File.separator + host +
     											"-" ;
     				if (fileName.startsWith(fileNamePrefix))
     					fileName = fileName.substring(fileNamePrefix.length(), fileName.length());
     				// get this server's task queue
     				RetrieveQueue serverQueue = (RetrieveQueue) getQueue(request.getHost());
     				fileName = fileNamePrefix + fileName;
     				request.setFileName(fileName);
     				// TODO
     				// jo ac? comprovaria quin protocol, m?tode, host, etc... i crearia un
     				// objecte que tractara la desc?rrega segons el m?tode que li toca.
     				// algo en plan Strategy's
     				//
     				// per exemple si fem URLRetrieveTask una abstracta i tenim
     				//
     				// GET de tota la vida
     				// serverQueue.put(new HTTPGetRetrieveTask(request, listener));
     				//
     				// POST
     				// serverQueue.put(new HTTPPostRetrieveTask(request, listener));
     				//
     				// FTP
     				// serverQueue.put(new FTPRetrieveTask(request, listener));
     				//
     				// ????Xarxa local?????
     				// serverQueue.put(new SMBRetrieveTask(request, listener));
     				// Enqueue the request and the listener will be notified when done.
     				URLRetrieveTask task = new URLRetrieveTask(request, listener);
     				return (URLRetrieveTask) serverQueue.put(task);
+    			}
     		} catch (MalformedURLException e) {
     			e.printStackTrace();
+    		}
     		return null;
+    	}
     	private IQueue getQueue(String hostName) {
     		RetrieveQueue queue = null;
     		if (serversTable.containsKey(hostName))
     			queue = (RetrieveQueue) serversTable.get(hostName);
     		else {
     			// crea la cola
     			queue = new RetrieveQueue(hostName);
     			// pone la cola del server en marcha.
+    		}
     		return queue;
+    	}
     	private Hashtable downloadedFiles;
     	private final String tempDirectoryPath = System.getProperty("java.io.tmpdir")+"tmp-andami";
     	/**
          * Remove an URL from the system cache. The file will remain in the file
          * system for further eventual uses.
          * @param request
          */
     	public void removeURLRequest(URLRequest request) {
     		if (downloadedFiles != null && downloadedFiles.containsKey(request))
     			downloadedFiles.remove(request);
+    	}
     	/**
          * 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
          */
         protected void addDownloadedURLRequest(URLRequest request, String filePath){
             if (downloadedFiles==null)
                 downloadedFiles = new Hashtable();
             String fileName = (String) downloadedFiles.put(request, filePath);
             if (fileName!=null){
                 File f = new File(fileName);
                 if (f.exists())
                     f.delete();
+            }
+        }
         /**
          * Returns the content of this 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 getPreviousDownloadedURLRequest(URLRequest request){
             File f = null;
             if (downloadedFiles!=null && downloadedFiles.containsKey(request)){
                 String filePath = (String) downloadedFiles.get(request);
                 f = new File(filePath);
+            }
             return f;
+        }
+    }

     /**
      * 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.remoteclient.taskplanning.retrieving;
     /**
      * @author jaume dominguez faus - jaume.dominguez@iver.es
      * Luis W. Sevilla (sevilla_lui@gva.es)
      */
     public class RetrieveEvent {
     	public static final int NOT_STARTED = 0;
     	public static final int CONNECTING = 1;
     	public static final int TRANSFERRING = 2;
     	public static final int REQUEST_FINISHED = 3;
     	public static final int REQUEST_FAILED = 4;
     	public static final int REQUEST_CANCELLED = 5;
     	public static final int POSTPROCESSING = 6;
     	/**
     	 * redundant; use REQUEST_FAILED
     	 * @deprecated ?
     	 */
     	public static final int ERROR = 11;
     	private int eventType;
     	public void setType(int type) {
     		eventType = type;
+    	}
     	public int getType() {
     		return eventType;
+    	}
+    }

     /**
      * 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.remoteclient.taskplanning.retrieving;
     import java.util.Date;
     import java.util.Vector;
     import org.gvsig.remoteclient.taskplanning.FIFOTaskPlanner;
     import org.gvsig.remoteclient.taskplanning.IQueue;
     import org.gvsig.remoteclient.taskplanning.IRunnableTask;
     import org.gvsig.remoteclient.taskplanning.ITaskPlanner;
     /**
      * @author jaume dominguez faus - jaume.dominguez@iver.es
      * 		   Luis W. Sevilla (sevilla_lui@gva.es)
      */
     public class RetrieveQueue implements IQueue {
     	private String hostName;
     	private Date startTime;
     	private Vector tasks = new Vector();
     	private boolean waiting;
     	private ITaskPlanner taskPlanner;
     	private Worker worker;
     	/**
+    	 *
     	 */
     	public RetrieveQueue(String hName) {
     		hostName = hName;
     		startTime = new Date();
     		worker = new Worker();
     		new Thread(worker).start();
+    	}
     	public IRunnableTask put(IRunnableTask task) {
     		tasks.add(task);
     		if (waiting) {
     			synchronized (this) {
     				notifyAll();
+    			}
+    		}
     		return task;
+    	}
     	public IRunnableTask take() {
     		if (tasks.isEmpty()) {
     			synchronized (this) {
     				waiting = true;
     				try {
     					wait();
     				} catch (InterruptedException ie) {
     					waiting = false;
+    				}
+    			}
+    		}
     		return getTaskPlanner().nextTask() ;
+    	}
     	public boolean isEmpty() {
     		synchronized (this) {
     			return tasks.isEmpty() && !worker.r.isRunning();
+    		}
+    	}
     	public ITaskPlanner getTaskPlanner() {
     		if (taskPlanner == null) {
     			taskPlanner = new FIFOTaskPlanner(this);
+    		}
     		return taskPlanner;
+    	}
     	public void setTaskPlanner(ITaskPlanner planner) {
     		taskPlanner = planner;
+    	}
     	public void pause() {
     		waiting = true;
+    	}
     	public void resume() {
     		waiting = false;
+    	}
     	public Vector getTasks() {
     		return tasks;
+    	}
     	private class Worker implements Runnable {
     		URLRetrieveTask r;
     		int i = 0;
     		public void run() {
     			while (true) {
     				r = (URLRetrieveTask) take();
     				r.execute();
+    			}
+    		}
+    	}
     	protected URLRetrieveTask getURLPreviousRequest(URLRequest request) {
     		// Is the one currently running?
     		/*URLRetrieveTask aux = (URLRetrieveTask) worker.r;
     		if (request.equals(aux.getRequest())) {
     				return aux;
     		}*/
     		// Is one of those in the queue?
     		for (int i = 0; i < tasks.size(); i++) {
     			URLRetrieveTask task = (URLRetrieveTask) tasks.get(i);
     			URLRequest aWorkingRequest = task.getRequest();
     			if (aWorkingRequest.equals(request)) {
     				return task;
+    			}
+    		}
     		return null;
+    	}
+    }

     /**
      * 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.remoteclient.taskplanning.retrieving;
     /**
      * @author Luis W. Sevilla (sevilla_lui@gva.es)
      */
     public interface RetrieveListener {
     	public void transferEventReceived(RetrieveEvent event);
+    }

     /**
      * 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.remoteclient.taskplanning.retrieving;
     import java.net.MalformedURLException;
     import java.net.URL;
     /**
      * @author Luis W. Sevilla (sevilla_lui@gva.es)
      */
     public class URLRequest{
     	public static final String HTTP = "http";
     	private volatile int hashCode = 0;
     	public static final int GET = 1;
     	public static final int POST = 2;
     	private int requestType = GET;
     	private String protocol;
     	private String host;
     	private int port = -1;
     	private String file;
     	private String fileName;
     	public URL getUrl() throws MalformedURLException {
     		String u = protocol;
     		u += "://"+host;
     		if (port != -1)
     			u += ":"+port;
     		u += "/"+file;
     		return new URL(u);
+    	}
     	/**
     	 * @return Returns the fileName.
     	 */
     	public String getFileName() {
     		return fileName;
+    	}
     	/**
     	 * @param fileName The fileName to set.
     	 */
     	public void setFileName(String fileName) {
     		this.fileName = fileName;
+    	}
     	/**
     	 * @return Returns the host.
     	 */
     	public String getHost() {
     		return host;
+    	}
     	/**
     	 * @param host The host to set.
     	 */
     	public void setHost(String host) {
     		this.host = host;
+    	}
     	/**
     	 * @return Returns the file.
     	 */
     	public String getFile() {
     		return file;
+    	}
     	/**
     	 * @param page The file to set.
     	 */
     	public void setFile(String page) {
     		this.file = page;
+    	}
     	/**
     	 * @return Returns the protocol.
     	 */
     	public String getProtocol() {
     		return protocol;
+    	}
     	/**
     	 * @param protocol The protocol to set.
     	 */
     	public void setProtocol(String protocol) {
     		this.protocol = protocol;
+    	}
     	/**
     	 * @return Returns the requestType.
     	 */
     	public int getRequestType() {
     		return requestType;
+    	}
     	/**
     	 * @param requestType The requestType to set.
     	 */
     	public void setRequestType(int requestType) {
     		this.requestType = requestType;
+    	}
     	/**
     	 * @return Returns the port.
     	 */
     	public int getPort() {
     		return port;
+    	}
     	/**
     	 * @param port The port to set.
     	 */
     	public void setPort(int port) {
     		this.port = port;
+    	}
     	public int hashCode() {
     		if (hashCode == 0) {
     			int result = 17;
     			String[] stringFields = new String[] {
     					fileName,
     					host,
     					file,
     					protocol
     			};
     			for (int i = 0; i < stringFields.length; i++) {
     				if (stringFields[i] != null)
     					for (int j = 0; j < stringFields[i].length(); j++)
     						result = 37*result + (int) stringFields[i].charAt(j);
+    			}
     			result = 37*result + port;
     			result = 37*result + requestType;
+    		}
     		return hashCode;
+    	}
     	public boolean equals(Object o) {
     		if (this == o)
     			return true;
     		if (!(o instanceof URLRequest))
     			return false;
     		URLRequest other = (URLRequest) o;
     		String[] stringFields = new String[] {
     				// this.fileName, NO!!! Do not check file name
     				this.host,
     				this.file,
     				this.protocol
     		};
     		String[] othersStringField = new String[] {
     				// other.fileName, NO!!! Do not check file name
     				other.host,
     				other.file,
     				other.protocol
     		};
     		for (int i = 0; i < stringFields.length; i++) {
     			if (stringFields[i] == null && othersStringField[i]!=null) return false;
     			if (stringFields[i] == null && othersStringField[i]!=null) return false;
     			if (stringFields[i] != null && othersStringField[i]!=null)
     				if (!stringFields[i].equals(othersStringField[i])) return false;
+    		}
     		if (this.port != other.port) return false;
     		if (this.requestType != other.requestType) return false;
     		return true;
+    	}
+    }

     /**
      * 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.remoteclient.taskplanning.retrieving;
     /*
      * Based on portions of code from EarthFlicks
      * http://today.java.net/lpt/a/212
      */
     import java.io.BufferedOutputStream;
     import java.io.DataOutputStream;
     import java.io.File;
     import java.io.FileOutputStream;
     import java.io.IOException;
     import java.io.InputStream;
     import java.net.MalformedURLException;
     import java.net.URL;
     import java.util.Iterator;
     import java.util.Vector;
     import org.gvsig.remoteclient.taskplanning.IRunnableTask;
     /**
      * Clase para bajar ficheros en un thread independiente.
      */
     public class URLRetrieveTask  implements IRunnableTask {
     	private boolean running, cancelled;
     	private URLRequest request;
     	private Vector listeners = new Vector();
     	private RetrieveEvent event = new RetrieveEvent();
     	private InputStream is;
     	/**
+    	 *
     	 */
     	public URLRetrieveTask(URLRequest request, RetrieveListener listener) {
     		this.request = request;
     		addRetrieveListener(listener);
     		running = cancelled = false;
+    	}
     	public void execute() {
     		event.setType(RetrieveEvent.NOT_STARTED);
     		fireEvent();
     		cancelled = false;
     		running= true;
     		long t = System.currentTimeMillis();
     		File f = new File(request.getFileName()+System.currentTimeMillis());
     		while (f.exists()) {
     			t++;
     			f = new File(request.getFileName()+t);
+    		}
     		URL url;
     		try {
     			event.setType(RetrieveEvent.CONNECTING);
     			fireEvent();
     			url = request.getUrl();
     			request.setFileName(f.getAbsolutePath());
     			System.out.println("downloading '"+url+"' to: "+f.getAbsolutePath());
     			DataOutputStream dos = new DataOutputStream( new BufferedOutputStream(new FileOutputStream(f)));
     			byte[] buffer = new byte[1024*256];
     			fireEvent();
     			is = url.openStream();
     			event.setType(RetrieveEvent.TRANSFERRING);
     			fireEvent();
     			if (!cancelled) {
     				long readed = 0;
     				for (int i = is.read(buffer); !cancelled && i>0; i = is.read(buffer)){
     					dos.write(buffer, 0, i);
     					readed += i;
+    				}
     				dos.close();
+    			}
     			if (cancelled) {
     				// Bad incomplete file, delete it.
     				System.out.println("download cancelled ("+url+")");
     				f.delete();
     			} else {
     				// register job in the cache
     				// TODO aix? deuria d'estar al principi per a poder capturar
     				// treballs que s'estan fent per? que encara no s'han acabat
     				synchronized (this) {
     					RequestManager.getInstance().addDownloadedURLRequest(request, f.getAbsolutePath());
+    				}
+    			}
     			running = false;
     			if (cancelled)
     				event.setType(RetrieveEvent.REQUEST_CANCELLED);
     			else
     				event.setType(RetrieveEvent.REQUEST_FINISHED);
     		} catch (MalformedURLException e) {
     			e.printStackTrace();
     			event.setType(RetrieveEvent.REQUEST_FAILED);
     		} catch (IOException e) {
     			e.printStackTrace();
     			event.setType(RetrieveEvent.REQUEST_FAILED);
+    		}
     		fireEvent();
+    	}
     	private void fireEvent() {
     		Iterator it = listeners.iterator();
     		while (it.hasNext()) {
     			RetrieveListener listener = (RetrieveListener) it.next();
     			listener.transferEventReceived(event);
+    		}
+    	}
     	public void addRetrieveListener(RetrieveListener l) {
     		if (l!=null)
     			listeners.add(l);
+    	}
     	public void cancel() {
     		cancelled = true;
     		try {
     			if (is != null) {
     				is.close();
     				is = null;
+    			}
     		} catch (IOException e) {
     			e.printStackTrace();
+    		}
+    	}
     	public boolean isRunning() {
     		return running && !cancelled;
+    	}
     	public URLRequest getRequest() {
     		return request;
+    	}
     	public Vector getListeners() {
     		return listeners;
+    	}
     	public long getTaskTimeout() {
     		return 30*1000;
+    	}
+    }
     //static private String makeSuffix(String contentType) {
     //	contentType = contentType.toLowerCase();
     //    if (contentType.indexOf("png") >= 0)
     //        return ".png";
     //
     //    if (contentType.indexOf("xml") >= 0)
     //        return ".xml";
     //
     //    if (contentType.indexOf("gif") >= 0)
     //        return ".gif";
     //
     //    if (contentType.indexOf("tif") >= 0)
     //        return ".tif";
     //
     //    if (contentType.indexOf("jpg") >= 0
     //        || contentType.indexOf("jpeg") >= 0)
     //        return ".jpg";
     //
     //    if (contentType.indexOf("html") >= 0)
     //        return ".html";
     //
     //    return "";
     //}
     ///**
     // *
     // */
     //private void end() {
     //}
     //
     ///**
     // *
     // */
     //private void inThreadEnd() {
     //}
     //
     ///**
     // *
     // */
     //private void update() {
     //}
     //
     ///**
     // *
     // */
     //private void begin() {
     //}
     //public void start() {
     //// this.reset();
     //this.thread = new Thread(this);
     //this.thread.start();
     //}
     /* (non-Javadoc)
     * @see java.lang.Runnable#run()
     * /
     public void run() {
     try {
     	URL url = request.getUrl();
     	this.status = Status.CONNECTING;
     	this.begin();
+        {
             // Retrieve the contents.
             int numBytesRead = 0;
     //        System.out.println("File being retrieved. " + this.getUrl().toString());
             java.net.URLConnection connection = url.openConnection();
             connection.setAllowUserInteraction(true);
             java.io.InputStream incoming = connection.getInputStream();
             this.contentLength = connection.getContentLength();
             this.contentType = connection.getContentType();
             java.io.File destFile = java.io.File.createTempFile("Cq_", makeSuffix(this.contentType));
             destFile.deleteOnExit(); // It's copied later if it's to be persisted.
             this.destination = destFile.getPath();
             java.io.FileOutputStream outgoing = new java.io.FileOutputStream(destFile);
             this.status = Status.RETRIEVING;
             byte[] buffer = new byte[4096];
             try {
                 while (!Thread.currentThread().isInterrupted() && numBytesRead >= 0) {
                     numBytesRead = incoming.read(buffer);
                     if (numBytesRead > 0) {
                         this.bytesRead += numBytesRead;
                         outgoing.write(buffer, 0, numBytesRead);
                         this.update();
+                    }
+                }
             } finally {
                 if (incoming != null)
                     try {incoming.close();} catch (java.io.IOException e) {}; // TODO: log it maybe
                 if (outgoing != null)
                     try {outgoing.close();} catch (java.io.IOException e) {}; // TODO: log it maybe
+            }
             this.status = Status.POSTPROCESSING;
+        }
     } catch (Exception e) {
         this.status = Status.ERROR;
         this.error = e;
         e.printStackTrace();
     } finally {
         if (Thread.currentThread().isInterrupted())
             this.status = Status.INTERRUPTED;
         this.update();
         this.inThreadEnd();
         if (this.status == Status.POSTPROCESSING)
             this.status = Status.DONE;
         this.end();
+    }
     }*/
     //File tempDirectory = new File(tempDirectoryPath);
     //if (!tempDirectory.exists())
     //tempDirectory.mkdir();
     //
     //f = new File(tempDirectoryPath+"/"+name+System.currentTimeMillis());
     //if (cancelled)
     //throw new TaskCancelledException();
     //addDownloadedURL(url, f.getAbsolutePath());
     //try {
     //URL url = request.getUrl();
     //System.out.println(url);
     //this.status = Status.CONNECTING;
     //this.begin();
     //
     //{
     //// Retrieve the contents.
     //int numBytesRead = 0;
     ////System.out.println("File being retrieved. " + this.getUrl().toString());
     //java.net.URLConnection connection = url.openConnection();
     //connection.setAllowUserInteraction(true);
     //java.io.InputStream incoming = connection.getInputStream();
     //this.contentLength = connection.getContentLength();
     //this.contentType = connection.getContentType();
     //
     //java.io.File destFile = java.io.File.createTempFile("Cq_", makeSuffix(this.contentType));
     //System.out.println(destFile.getAbsolutePath());
     ////destFile.deleteOnExit(); // It's copied later if it's to be persisted.
     //this.destination = destFile.getPath();
     //java.io.FileOutputStream outgoing = new java.io.FileOutputStream(destFile);
     //
     //this.status = Status.RETRIEVING;
     //
     //byte[] buffer = new byte[4096];
     //
     //try {
     //while (!Thread.currentThread().isInterrupted() && numBytesRead >= 0) {
     //numBytesRead = incoming.read(buffer);
     //if (numBytesRead > 0) {
     //this.bytesRead += numBytesRead;
     //outgoing.write(buffer, 0, numBytesRead);
     //this.update();
     //}
     //}
     //} finally {
     //if (incoming != null)
     //try {incoming.close();} catch (java.io.IOException e) {}; // TODO: log it maybe
     //if (outgoing != null)
     //try {outgoing.close();} catch (java.io.IOException e) {}; // TODO: log it maybe
     //}
     //this.status = Status.POSTPROCESSING;
     //}
     //} catch (Exception e) {
     //this.status = Status.ERROR;
     //this.error = e;
     //e.printStackTrace();
     //} finally {
     //if (Thread.currentThread().isInterrupted())
     //this.status = Status.INTERRUPTED;
     //this.update();
     //this.inThreadEnd();
     //if (this.status == Status.POSTPROCESSING)
     //this.status = Status.DONE;
     //this.end();
     //}

     <!--
         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.
     -->
     <body>
     <h4>Gestor de downloads multihilo</h4>
     <p>Permite mantener en threads separados las peticiones a servidores remotos
     (http, ftp, etc), de manera que el flujo normal de ejecuci?n del programa
     no se quede detenido cuando se realiza una petici?n.</p>
     <p>RetrieveManager es el gestor de peticiones. Tiene una tabla de colas
      de petici?n que son las que atienden esas peticiones. Se crea una cola
      para cada server que se invoque, y esta es la que gestionar? las
      peticiones que se realicen a ese server, hasta el fin de la ejecuci?n
      del programa.</p>
     <p>RetrieveQueue es la clase que realiza las peticiones. Mantiene las
     prioridades, resuelve los timeouts, etc. Solo mantiene una petici?n
     'activa' simultaneamente. Las dem?s esperan a que esta termine.</p>
     <p>Retriever es la clase 'petici?n' propiamente dicha. Habla con el server,
     se baja los datos, y le comunica al listener lo que est? pasando</p>
     <p>RetrieveRequest es la clase que contiene los datos de la conexi?n. En
     principio permite GET y POST sobre HTTP, pero se puede extender si hace
     falta algo distinto</p>
     <p>RetrieveListener es el interface que implementa el objeto que vaya a
     monitorizar el progreso del Retriever, y el que deber? actuar en consecuencia.</p>
     <p>RetrieveEvent es la clase mediante la que se notifica al Listener
     la evoluci?n de la petici?n.</p>
     <p>RetrieveException excepci?n gen?rica de este package.</p>
     </body>

     /**
      * 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.remoteclient;
     import org.gvsig.compat.net.ICancellable;
     /**
      * <p></p>
+     *
      */
     public abstract class RemoteClient {
     /**
      * <p>Represents ...</p>
+     *
      */
         protected String hostName;
     /**
      * <p>Represents ...</p>
+     *
      */
         protected int port;
     /**
      * <p>Represents ...</p>
+     *
      */
         protected String serviceName;
     /**
      * <p>Represents ...</p>
+     *
      */
         private String type;
     /**
      * <p>Represents ...</p>
+     *
      */
         private String subtype;
     /**
      * <p>Represents ...</p>
+     *
+     *
      * @return
      */
         public String getHost() {
             return hostName;
+        }
     /**
      * <p>Represents ...</p>
+     *
+     *
      * @param _hostName
      */
         public void setHost(String _hostName) {
             hostName = _hostName;

Application: gvSIG desktop

Revision 45832