Changeset 10726 for trunk/gli/src/org/greenstone/gatherer/remote/RemoteGreenstoneServer.java

Timestamp:

2005-10-14T15:19:36+13:00 (19 years ago)

Author:

mdewsnip

Message:

(MAJOR CHANGE) This is the remote Greenstone building functionality implemented for the West Yorkshire Fire and Rescue Service. It allows collections to be built without having a local version of Greenstone, using either a stand-alone version of the GLI or the applet.

The collections are stored on the server (allowing people to collaborate on collections -- but not at the same time), and only what is necessary to let the user edit the collection is downloaded. Any changes to the collection are uploaded to the server.

An access restriction mechanism is implemented which uses the standard Greenstone user database to control who has access to collections.

File:

• trunk/gli/src/org/greenstone/gatherer/remote/RemoteGreenstoneServer.java (modified) (2 diffs)

trunk/gli/src/org/greenstone/gatherer/remote/RemoteGreenstoneServer.java

@@ -6 +6 @@
  * University of Waikato, New Zealand.
  *
- * Author: David Bainbridge, Greenstone Digital Library, University of Waikato
+ * Author: Michael Dewsnip, NZDL Project, University of Waikato
  *
  * Copyright (C) 2005 New Zealand Digital Library Project
@@ -30 +30 @@
 import java.io.*;
 import java.net.*;
+import java.util.*;
+import java.util.zip.*;
+import javax.swing.*;
 import org.greenstone.gatherer.Configuration;
 import org.greenstone.gatherer.DebugStream;
+import org.greenstone.gatherer.Dictionary;
+import org.greenstone.gatherer.GAuthenticator;
 import org.greenstone.gatherer.Gatherer;
-import org.greenstone.gatherer.file.FileNode;
+import org.greenstone.gatherer.collection.CollectionManager;
 import org.greenstone.gatherer.shell.GShell;
+import org.greenstone.gatherer.util.Utility;
+import org.greenstone.gatherer.util.ZipTools;
 
 
 public class RemoteGreenstoneServer
 {
-    static public boolean deleteCollectionFile(String collection_name, File collection_file)
-    {
-    return true;
-    }
-
-
-    static public boolean downloadCollection(String collection_name)
-    {
-    return true;
-    }
-
-
-    static public boolean downloadCollectionConfigurations()
-    {
-    return true;
-    }
-
-
-    static public boolean downloadCollectionFile(String collection_name, File collection_file)
-    {
-    return true;
-    }
-
-
-    static public Boolean moveCollectionFile(String collection_name, File source_collection_file, File target_collection_file)
-    {
-    return null;
-    }
-
-
-    static public Boolean newCollectionDirectory(String collection_name, File new_collection_directory)
-    {
-    return null;
-    }
-
-
-    static public boolean uploadCollectionFile(String collection_name, File collection_file)
-    {
-    return true;
-    }
-
-
-    static public boolean uploadCollectionFiles(String collection_name, File[] collection_files)
-    {
-    return true;
-    }
-
-
-    static public Boolean uploadFilesIntoCollection(String collection_name, File[] source_files, File target_collection_directory)
-    {
-    return null;
-    }
-
-
-    static public void download_url_zip(String col_name, String dir, GShell source, String accept_expr, String reject_expr)
-    {
-    try {
-        String download_cgi  = Gatherer.cgiBase + "download";
-
-        // Send col_name and dir arguments to download cgi
-        String col_name_encoded = URLEncoder.encode(col_name,"UTF-8");
-        String dir_encoded = URLEncoder.encode(dir,"UTF-8");
-        String cgi_args = "c=" + col_name_encoded;
-        cgi_args += "&dir=" + dir_encoded + "&a=" + accept_expr + "&r=" + reject_expr;
-
-        URL download_url = new URL(download_cgi);
-
-        System.err.println("**** download cgi = '" + download_cgi + "'");
-        System.err.println("**** cgi args = '" + cgi_args + "'");
-
-        URLConnection dl_connection = download_url.openConnection();
-        dl_connection.setDoOutput(true);        
-        OutputStream dl_os = dl_connection.getOutputStream();
-
-        PrintWriter dl_out = new PrintWriter(dl_os);
-        dl_out.println(cgi_args);
-        dl_out.close();
-
-        // Download result from running cgi script
-        InputStream dl_is = dl_connection.getInputStream();
-        BufferedInputStream dl_bis = new BufferedInputStream(dl_is); 
-        DataInputStream dl_dbis = new DataInputStream(dl_bis);
-            
-        // set up output stream for zip download
-        String col_dir;
-        if (col_name.startsWith("/")) {
-        col_dir = Configuration.gsdl_path;
+    // ----------------------------------------------------------------------------------------------------
+    //   PUBLIC LAYER
+    // ----------------------------------------------------------------------------------------------------
+
+
+    static public String deleteCollection(String collection_name)
+    {
+    return performAction(new RemoteGreenstoneServerDeleteCollectionAction(collection_name));
+    }
+
+
+    static public String deleteCollectionFile(String collection_name, File collection_file)
+    {
+    return performAction(new RemoteGreenstoneServerDeleteCollectionFileAction(collection_name, collection_file));
+    }
+
+
+    static public String downloadCollection(String collection_name)
+    {
+    return performAction(new RemoteGreenstoneServerDownloadCollectionAction(collection_name));
+    }
+
+
+    static public String downloadCollectionArchives(String collection_name)
+    {
+    return performAction(new RemoteGreenstoneServerDownloadCollectionArchivesAction(collection_name));
+    }
+
+
+    static public String downloadCollectionConfigurations()
+    {
+    return performAction(new RemoteGreenstoneServerDownloadCollectionConfigurationsAction());
+    }
+
+
+    static public String downloadCollectionFile(String collection_name, File collection_file)
+    {
+    return performAction(new RemoteGreenstoneServerDownloadCollectionFileAction(collection_name, collection_file));
+    }
+
+
+    static public String getScriptOptions(String script_name, String script_arguments)
+    {
+    return performAction(new RemoteGreenstoneServerGetScriptOptionsAction(script_name, script_arguments));
+    }
+
+
+    static public String moveCollectionFile(String collection_name, File source_collection_file, File target_collection_file)
+    {
+    return performAction(new RemoteGreenstoneServerMoveCollectionFileAction(collection_name, source_collection_file, target_collection_file));
+    }
+
+
+    static public String newCollectionDirectory(String collection_name, File new_collection_directory)
+    {
+    return performAction(new RemoteGreenstoneServerNewCollectionDirectoryAction(collection_name, new_collection_directory));
+    }
+
+
+    static public String runScript(String collection_name, String script_name, String script_arguments, GShell shell)
+    {
+    return performAction(new RemoteGreenstoneServerRunScriptAction(collection_name, script_name, script_arguments, shell));
+    }
+
+
+    static public String uploadCollectionFile(String collection_name, File collection_file)
+    {
+    return performAction(new RemoteGreenstoneServerUploadCollectionFilesAction(collection_name, new File[] { collection_file }));
+    }
+
+
+    static public String uploadCollectionFiles(String collection_name, File[] collection_files)
+    {
+    return performAction(new RemoteGreenstoneServerUploadCollectionFilesAction(collection_name, collection_files));
+    }
+
+
+    static public String uploadFilesIntoCollection(String collection_name, File[] source_files, File target_collection_directory)
+    {
+    return performAction(new RemoteGreenstoneServerUploadFilesIntoCollectionAction(collection_name, source_files, target_collection_directory));
+    }
+
+
+    // ----------------------------------------------------------------------------------------------------
+
+
+    static public void exit()
+    {
+    System.err.println("Exiting, number of jobs on queue: " + remote_greenstone_server_action_queue.size());
+
+    // If there are still jobs on the queue we must wait for the jobs to finish
+    while (remote_greenstone_server_action_queue.size() > 0) {
+        synchronized (remote_greenstone_server_action_queue) {
+        try {
+            DebugStream.println("Waiting for queue to become empty...");
+            remote_greenstone_server_action_queue.wait(500);
+        }
+        catch (InterruptedException exception) {}
+        }
+    }
+    }
+
+
+    // ----------------------------------------------------------------------------------------------------
+    //   QUEUE LAYER
+    // ----------------------------------------------------------------------------------------------------
+
+
+    /** Returns null if we cannot wait for the action to finish, "" if the action failed, or the action output. */
+    static private String performAction(RemoteGreenstoneServerAction remote_greenstone_server_action)
+    {
+    // Add the action to the queue
+    remote_greenstone_server_action_queue.addAction(remote_greenstone_server_action);
+
+    // If we're running in the GUI thread we must return immediately
+    // We cannot wait for the action to complete because this will block any GUI updates
+    if (SwingUtilities.isEventDispatchThread()) {
+        System.err.println("WARNING: In event dispatch thread, returning immediately...");
+        return null;
+    }
+
+    // Otherwise wait until the action is processed
+    while (!remote_greenstone_server_action.processed) {
+        synchronized (remote_greenstone_server_action) {
+        try {
+            DebugStream.println("Waiting for action to complete...");
+            remote_greenstone_server_action.wait(500);
+        }
+        catch (InterruptedException exception) {}
+        }
+    }
+
+    // Return "" if the action failed
+    if (!remote_greenstone_server_action.processed_successfully) {
+        return "";
+    }
+    // Otherwise return the action output
+    return remote_greenstone_server_action.action_output;
+    }
+
+
+    static private RemoteGreenstoneServerActionQueue remote_greenstone_server_action_queue = new RemoteGreenstoneServerActionQueue();
+
+
+    static private class RemoteGreenstoneServerActionQueue
+    extends Thread
+    {
+    /** The queue of waiting jobs. */
+    private ArrayList queue = null;
+
+
+    public RemoteGreenstoneServerActionQueue()
+    {
+        if (Gatherer.isGsdlRemote) {
+        queue = new ArrayList();
+        start();
+        }
+    }
+
+
+    synchronized public void addAction(RemoteGreenstoneServerAction remote_greenstone_server_action)
+    {
+        queue.add(remote_greenstone_server_action);
+        notifyAll();
+    }
+
+
+    public int size()
+    {
+        return queue.size();
+    }
+
+
+    public void run()
+    {
+        while (true) {
+        // If there are jobs on the queue, get the next in line and process it
+        if (queue.size() > 0) {
+            RemoteGreenstoneServerAction remote_greenstone_server_action = (RemoteGreenstoneServerAction) queue.get(0);
+
+            try {
+            remote_greenstone_server_action.perform();
+
+            // No exceptions were thrown, so the action was successful
+            remote_greenstone_server_action.processed_successfully = true;
+            }
+            catch (RemoteGreenstoneServerActionCancelledException exception) {
+            remote_greenstone_server_action.processed_successfully = false;
+            }
+            catch (Exception exception) {
+            DebugStream.printStackTrace(exception);
+            JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("RemoteGreenstoneServer.Error", exception.getMessage()), Dictionary.get("RemoteGreenstoneServer.Error_Title"), JOptionPane.ERROR_MESSAGE);
+            remote_greenstone_server_action.processed_successfully = false;
+            }
+
+            // We're done with this action, for better or worse
+            remote_greenstone_server_action.processed = true;
+            progress_bar.setAction(null);
+            queue.remove(0);
+        }
+
+        // Otherwise the queue is empty
+        else {
+            // Wait until we are notify()ed by addAction that there is a new job on the queue
+            synchronized (this) {
+            try {
+                wait();
+            }
+            catch (InterruptedException exception) { }
+            }
+        }
+        }
+    }
+    }
+
+
+    // ----------------------------------------------------------------------------------------------------
+    //   PROGRESS BAR
+    // ----------------------------------------------------------------------------------------------------
+
+
+    static private RemoteGreenstoneServerProgressBar progress_bar = new RemoteGreenstoneServerProgressBar();
+
+
+    static private class RemoteGreenstoneServerProgressBar
+    extends JProgressBar
+    {
+    public RemoteGreenstoneServerProgressBar()
+    {
+        setBackground(Configuration.getColor("coloring.collection_tree_background", false));
+        setForeground(Configuration.getColor("coloring.collection_tree_foreground", false));
+        setString(Dictionary.get("FileActions.No_Activity"));
+        setStringPainted(true);
+    }
+
+
+    public void setAction(String action)
+    {
+        if (action != null) {
+        DebugStream.println(action);
+        }
+
+        // We cannot call this from the GUI thread otherwise the progress bar won't start
+        if (SwingUtilities.isEventDispatchThread()) {
+        System.err.println("ERROR: RemoteGreenstoneServerProgressBar.setAction() called from event dispatch thread!");
+        return;
+        }
+
+        // Set the string on the progress bar, and start or stop it
+        if (action == null) {
+        setString(Dictionary.get("FileActions.No_Activity"));
+        setIndeterminate(false);
         }
         else {
-        col_dir = Gatherer.getCollectDirectoryPath();
-        }
-
-        String zip_fname = col_dir + col_name + ".zip";
-        FileOutputStream zip_fos = new FileOutputStream(zip_fname);
+        setString(action);
+        setIndeterminate(true);
+        }
+    }
+    }
+
+
+    static public RemoteGreenstoneServerProgressBar getProgressBar()
+    {
+    return progress_bar;
+    }
+
+
+    // ----------------------------------------------------------------------------------------------------
+    //   ACTIONS
+    // ----------------------------------------------------------------------------------------------------
+
+
+    static private abstract class RemoteGreenstoneServerAction
+    {
+    public String action_output = null;
+    public boolean processed = false;
+    public boolean processed_successfully;
+
+    abstract public void perform()
+        throws Exception;
+    }
+
+
+    static private class RemoteGreenstoneServerActionCancelledException
+    extends Exception
+    {
+    }
+
+
+    /**
+     * --------------------------------------------------------------------------------------------
+     *    DELETE COLLECTION
+     * --------------------------------------------------------------------------------------------
+     */
+    static private class RemoteGreenstoneServerDeleteCollectionAction
+    extends RemoteGreenstoneServerAction
+    {
+    private String collection_name;
+
+    public RemoteGreenstoneServerDeleteCollectionAction(String collection_name)
+    {
+        this.collection_name = collection_name;
+    }
+
+    public void perform()
+        throws Exception
+    {
+        progress_bar.setAction("Deleting collection " + collection_name + "...");
+
+        String delete_collection_command = "cmd=delete-collection";
+        delete_collection_command += "&c=" + URLEncoder.encode(collection_name, "UTF-8");
+        action_output = sendCommandToServer(delete_collection_command, null);
+    }
+    }
+
+
+    /**
+     * --------------------------------------------------------------------------------------------
+     *    DELETE COLLECTION FILE
+     * --------------------------------------------------------------------------------------------
+     */
+    static private class RemoteGreenstoneServerDeleteCollectionFileAction
+    extends RemoteGreenstoneServerAction
+    {
+    private String collection_name;
+    private File collection_file;
+
+    public RemoteGreenstoneServerDeleteCollectionFileAction(String collection_name, File collection_file)
+    {
+        this.collection_name = collection_name;
+        this.collection_file = collection_file;
+    }
+
+    public void perform()
+        throws Exception
+    {
+        String collection_directory_path = CollectionManager.getCollectionDirectoryPath(collection_name);
+        String collection_file_relative_path = getPathRelativeToDirectory(collection_file, collection_directory_path);
+        collection_file_relative_path = collection_file_relative_path.replaceAll((Utility.isWindows() ? "\\\\" : "\\/"), "|");
+        progress_bar.setAction("Deleting collection file " + collection_file_relative_path + "...");
+
+        String delete_collection_file_command = "cmd=delete-collection-file";
+        delete_collection_file_command += "&c=" + URLEncoder.encode(collection_name, "UTF-8");
+        delete_collection_file_command += "&file=" + URLEncoder.encode(collection_file_relative_path, "UTF-8");
+        action_output = sendCommandToServer(delete_collection_file_command, null);
+    }
+    }
+
+
+    /**
+     * --------------------------------------------------------------------------------------------
+     *    DOWNLOAD COLLECTION
+     * --------------------------------------------------------------------------------------------
+     */
+    static private class RemoteGreenstoneServerDownloadCollectionAction
+    extends RemoteGreenstoneServerAction
+    {
+    private String collection_name;
+
+    public RemoteGreenstoneServerDownloadCollectionAction(String collection_name)
+    {
+        this.collection_name = collection_name;
+    }
+
+    public void perform()
+        throws Exception
+    {
+        progress_bar.setAction("Downloading remote collection " + collection_name + "...");
+
+        String download_collection_command = "cmd=download-collection";
+        download_collection_command += "&c=" + URLEncoder.encode(collection_name, "UTF-8");
+        String zip_file_path = Gatherer.getCollectDirectoryPath() + collection_name + ".zip";
+        action_output = downloadFile(download_collection_command, zip_file_path);
+
+        // Delete the existing (local) collection
+        Gatherer.c_man.deleteCollection(collection_name);
+
+        // Unzip the collection just downloaded
+        ZipTools.unzipFile(zip_file_path, Gatherer.getCollectDirectoryPath());
+    }
+    }
+
+
+    /**
+     * --------------------------------------------------------------------------------------------
+     *    DOWNLOAD COLLECTION ARCHIVES
+     * --------------------------------------------------------------------------------------------
+     */
+    static private class RemoteGreenstoneServerDownloadCollectionArchivesAction
+    extends RemoteGreenstoneServerAction
+    {
+    private String collection_name;
+
+    public RemoteGreenstoneServerDownloadCollectionArchivesAction(String collection_name)
+    {
+        this.collection_name = collection_name;
+    }
+
+    public void perform()
+        throws Exception
+    {
+        progress_bar.setAction("Downloading collection archives for " + collection_name + "...");
+
+        String download_collection_archives_command = "cmd=download-collection-archives";
+        download_collection_archives_command += "&c=" + URLEncoder.encode(collection_name, "UTF-8");
+        String zip_file_path = Gatherer.getCollectDirectoryPath() + collection_name + "-archives.zip";
+        action_output = downloadFile(download_collection_archives_command, zip_file_path);
+
+        // Delete the existing (local) collection archives
+        Utility.delete(new File(Gatherer.c_man.getCollectionArchivesDirectoryPath()));
+
+        // Unzip the collection archives just downloaded
+        ZipTools.unzipFile(zip_file_path, Gatherer.getCollectDirectoryPath());
+    }
+    }
+
+
+    /**
+     * --------------------------------------------------------------------------------------------
+     *    DOWNLOAD COLLECTION CONFIGURATIONS
+     * --------------------------------------------------------------------------------------------
+     */
+    static private class RemoteGreenstoneServerDownloadCollectionConfigurationsAction
+    extends RemoteGreenstoneServerAction
+    {
+    public RemoteGreenstoneServerDownloadCollectionConfigurationsAction()
+    {
+    }
+
+    public void perform()
+        throws Exception
+    {
+        progress_bar.setAction("Downloading collection configurations...");
+
+        // Delete the existing (local) collect directory
+        Utility.delete(new File(Gatherer.getCollectDirectoryPath()));
+        new File(Gatherer.getCollectDirectoryPath()).mkdirs();
+
+        String download_collection_configurations_command = "cmd=download-collection-configurations";
+        String zip_file_path = Gatherer.getCollectDirectoryPath() + "collections.zip";
+        action_output = downloadFile(download_collection_configurations_command, zip_file_path);
+
+        // Unzip the collection configurations just downloaded
+        ZipTools.unzipFile(zip_file_path, Gatherer.getCollectDirectoryPath());
+    }
+    }
+
+
+    /**
+     * --------------------------------------------------------------------------------------------
+     *    DOWNLOAD COLLECTION FILE
+     * --------------------------------------------------------------------------------------------
+     */
+    static private class RemoteGreenstoneServerDownloadCollectionFileAction
+    extends RemoteGreenstoneServerAction
+    {
+    private String collection_name;
+    private File collection_file;
+
+    public RemoteGreenstoneServerDownloadCollectionFileAction(String collection_name, File collection_file)
+    {
+        this.collection_name = collection_name;
+        this.collection_file = collection_file;
+    }
+
+    public void perform()
+        throws Exception
+    {
+        String collection_directory_path = CollectionManager.getCollectionDirectoryPath(collection_name);
+        String collection_file_relative_path = getPathRelativeToDirectory(collection_file, collection_directory_path);
+        collection_file_relative_path = collection_file_relative_path.replaceAll((Utility.isWindows() ? "\\\\" : "\\/"), "|");
+        progress_bar.setAction("Downloading collection file " + collection_file_relative_path + "...");
+
+        String download_collection_file_command = "cmd=download-collection-file";
+        download_collection_file_command += "&c=" + URLEncoder.encode(collection_name, "UTF-8");
+        download_collection_file_command += "&file=" + URLEncoder.encode(collection_file_relative_path, "UTF-8");
+        String zip_file_name = collection_name + "-" + collection_file.getName() + ".zip";
+        String zip_file_path = collection_directory_path + zip_file_name;
+        action_output = downloadFile(download_collection_file_command, zip_file_path);
+
+        // Unzip the collection file just downloaded
+        ZipTools.unzipFile(zip_file_path, collection_directory_path);
+    }
+    }
+
+
+    /**
+     * --------------------------------------------------------------------------------------------
+     *    GET SCRIPT OPTIONS
+     * --------------------------------------------------------------------------------------------
+     */
+    static private class RemoteGreenstoneServerGetScriptOptionsAction
+    extends RemoteGreenstoneServerAction
+    {
+    private String script_name;
+    private String script_arguments;
+
+    public RemoteGreenstoneServerGetScriptOptionsAction(String script_name, String script_arguments)
+    {
+        this.script_name = script_name;
+        this.script_arguments = script_arguments;
+    }
+
+    public void perform()
+        throws Exception
+    {
+        progress_bar.setAction("Getting options for " + script_name + "...");
+
+        String get_script_options_command = "cmd=get-script-options";
+        get_script_options_command += "&script=" + script_name;
+        get_script_options_command += "&xml=";
+        get_script_options_command += "&language=" + Configuration.getLanguage();
+        get_script_options_command += script_arguments;
+        action_output = sendCommandToServer(get_script_options_command, null);
+    }
+    }
+
+
+    /**
+     * --------------------------------------------------------------------------------------------
+     *    MOVE COLLECTION FILE
+     * --------------------------------------------------------------------------------------------
+     */
+    static private class RemoteGreenstoneServerMoveCollectionFileAction
+    extends RemoteGreenstoneServerAction
+    {
+    private String collection_name;
+    private File source_collection_file;
+    private File target_collection_file;
+
+    public RemoteGreenstoneServerMoveCollectionFileAction(String collection_name, File source_collection_file, File target_collection_file)
+    {
+        this.collection_name = collection_name;
+        this.source_collection_file = source_collection_file;
+        this.target_collection_file = target_collection_file;
+    }
+
+    public void perform()
+        throws Exception
+    {
+        String collection_directory_path = CollectionManager.getCollectionDirectoryPath(collection_name);
+        String source_collection_file_relative_path = getPathRelativeToDirectory(source_collection_file, collection_directory_path);
+        source_collection_file_relative_path = source_collection_file_relative_path.replaceAll((Utility.isWindows() ? "\\\\" : "\\/"), "|");
+        String target_collection_file_relative_path = getPathRelativeToDirectory(target_collection_file, collection_directory_path);
+        target_collection_file_relative_path = target_collection_file_relative_path.replaceAll((Utility.isWindows() ? "\\\\" : "\\/"), "|");
+        progress_bar.setAction("Moving file " + source_collection_file_relative_path + " -> " + target_collection_file_relative_path + "...");
+
+        String move_collection_file_command = "cmd=move-collection-file";
+        move_collection_file_command += "&c=" + URLEncoder.encode(collection_name, "UTF-8");
+        move_collection_file_command += "&source=" + URLEncoder.encode(source_collection_file_relative_path, "UTF-8");
+        move_collection_file_command += "&target=" + URLEncoder.encode(target_collection_file_relative_path, "UTF-8");
+        action_output = sendCommandToServer(move_collection_file_command, null);
+    }
+    }
+
+
+    /**
+     * --------------------------------------------------------------------------------------------
+     *    NEW COLLECTION DIRECTORY
+     * --------------------------------------------------------------------------------------------
+     */
+    static private class RemoteGreenstoneServerNewCollectionDirectoryAction
+    extends RemoteGreenstoneServerAction
+    {
+    private String collection_name;
+    private File new_collection_directory;
+
+    public RemoteGreenstoneServerNewCollectionDirectoryAction(String collection_name, File new_collection_directory)
+    {
+        this.collection_name = collection_name;
+        this.new_collection_directory = new_collection_directory;
+    }
+
+    public void perform()
+        throws Exception
+    {
+        String collection_directory_path = CollectionManager.getCollectionDirectoryPath(collection_name);
+        String new_collection_directory_relative_path = getPathRelativeToDirectory(new_collection_directory, collection_directory_path);
+        new_collection_directory_relative_path = new_collection_directory_relative_path.replaceAll((Utility.isWindows() ? "\\\\" : "\\/"), "|");
+        progress_bar.setAction("Creating new directory " + new_collection_directory_relative_path + "...");
+
+        String new_collection_directory_command = "cmd=new-collection-directory";
+        new_collection_directory_command += "&c=" + URLEncoder.encode(collection_name, "UTF-8");
+        new_collection_directory_command += "&directory=" + URLEncoder.encode(new_collection_directory_relative_path, "UTF-8");
+        action_output = sendCommandToServer(new_collection_directory_command, null);
+    }
+    }
+
+
+    /**
+     * --------------------------------------------------------------------------------------------
+     *    RUN SCRIPT
+     * --------------------------------------------------------------------------------------------
+     */
+    static private class RemoteGreenstoneServerRunScriptAction
+    extends RemoteGreenstoneServerAction
+    {
+    private String collection_name;
+    private String script_name;
+    private String script_arguments;
+    private GShell shell;
+
+    public RemoteGreenstoneServerRunScriptAction(String collection_name, String script_name, String script_arguments, GShell shell)
+    {
+        this.collection_name = collection_name;
+        this.script_name = script_name;
+        this.script_arguments = script_arguments;
+        this.shell = shell;
+    }
+
+    public void perform()
+        throws Exception
+    {
+        progress_bar.setAction("Running " + script_name + "...");
+
+        String run_script_command = "cmd=run-script";
+        run_script_command += "&c=" + URLEncoder.encode(collection_name, "UTF-8");
+        run_script_command += "&script=" + script_name;
+        run_script_command += "&language=" + Configuration.getLanguage();
+        run_script_command += script_arguments;
+        action_output = sendCommandToServer(run_script_command, shell);
+    }
+    }
+
+
+    /**
+     * --------------------------------------------------------------------------------------------
+     *    UPLOAD COLLECTION FILE
+     * --------------------------------------------------------------------------------------------
+     */
+    static private class RemoteGreenstoneServerUploadCollectionFilesAction
+    extends RemoteGreenstoneServerAction
+    {
+    private String collection_name;
+    private File[] collection_files;
+
+
+    public RemoteGreenstoneServerUploadCollectionFilesAction(String collection_name, File[] collection_files)
+    {
+        this.collection_name = collection_name;
+        this.collection_files = collection_files;
+    }
+
+
+    public void perform()
+        throws Exception
+    {
+        progress_bar.setAction("Uploading collection files...");
+
+        // Determine the file paths relative to the collection directory
+        String collection_directory_path = CollectionManager.getCollectionDirectoryPath(collection_name);
+        String[] collection_file_relative_paths = new String[collection_files.length];
+        for (int i = 0; i < collection_files.length; i++) {
+        collection_file_relative_paths[i] = getPathRelativeToDirectory(collection_files[i], collection_directory_path);
+        }
+
+        // Zip up the files to send to the server
+        String zip_file_name = collection_name + "-" + System.currentTimeMillis() + ".zip";
+        String zip_file_path = collection_directory_path + zip_file_name;
+        ZipTools.zipFiles(zip_file_path, collection_directory_path, collection_file_relative_paths);
+
+        // Upload the zip file
+        String upload_collection_file_command = "cmd=upload-collection-file";
+        upload_collection_file_command += "&c=" + URLEncoder.encode(collection_name, "UTF-8");
+        upload_collection_file_command += "&file=" + URLEncoder.encode(zip_file_name, "UTF-8");
+        upload_collection_file_command += "&directory=";
+        upload_collection_file_command += "&zip=true";
+        action_output = uploadFile(upload_collection_file_command, zip_file_path);
+    }
+    }
+
+
+    /**
+     * --------------------------------------------------------------------------------------------
+     *    UPLOAD FILES INTO COLLECTION
+     * --------------------------------------------------------------------------------------------
+     */
+    static private class RemoteGreenstoneServerUploadFilesIntoCollectionAction
+    extends RemoteGreenstoneServerAction
+    {
+    private String collection_name;
+    private File[] source_files;
+    private File target_collection_directory;
+
+
+    public RemoteGreenstoneServerUploadFilesIntoCollectionAction(String collection_name, File[] source_files, File target_collection_directory)
+    {
+        this.collection_name = collection_name;
+        this.source_files = source_files;
+        this.target_collection_directory = target_collection_directory;
+    }
+
+
+    public void perform()
+        throws Exception
+    {
+        String collection_directory_path = CollectionManager.getCollectionDirectoryPath(collection_name);
+        String target_collection_directory_relative_path = getPathRelativeToDirectory(target_collection_directory, collection_directory_path);
+        target_collection_directory_relative_path = target_collection_directory_relative_path.replaceAll((Utility.isWindows() ? "\\\\" : "\\/"), "|");
+        progress_bar.setAction("Uploading files into collection...");
+
+        String zip_file_name = collection_name + "-" + System.currentTimeMillis() + ".zip";
+        String zip_file_path = Gatherer.getCollectDirectoryPath() + zip_file_name;
+        DebugStream.println("Zip file path: " + zip_file_path);
+
+        String base_directory_path = source_files[0].getParentFile().getAbsolutePath();
+        DebugStream.println("Base directory path: " + base_directory_path);
+        String[] source_file_relative_paths = new String[source_files.length];
+        for (int i = 0; i < source_files.length; i++) {
+        DebugStream.println("Source file path: " + source_files[i]);
+        source_file_relative_paths[i] = getPathRelativeToDirectory(source_files[i], base_directory_path);
+        }
+
+        ZipTools.zipFiles(zip_file_path, base_directory_path, source_file_relative_paths);
+
+        String upload_collection_file_command = "cmd=upload-collection-file";
+        upload_collection_file_command += "&c=" + URLEncoder.encode(collection_name, "UTF-8");
+        upload_collection_file_command += "&file=" + URLEncoder.encode(zip_file_name, "UTF-8");
+        upload_collection_file_command += "&directory=" + URLEncoder.encode(target_collection_directory_relative_path, "UTF-8");
+        upload_collection_file_command += "&zip=true";
+        action_output = uploadFile(upload_collection_file_command, zip_file_path);
+    }
+    }
+
+
+    // ----------------------------------------------------------------------------------------------------
+    //   AUTHENTICATION LAYER
+    // ----------------------------------------------------------------------------------------------------
+
+
+    static private PasswordAuthentication remote_greenstone_server_authentication = null;
+    // static private PasswordAuthentication remote_greenstone_server_authentication = new PasswordAuthentication(System.getProperty("user.name"), new char[] { });
+
+
+    static private class RemoteGreenstoneServerAuthenticateTask
+    extends Thread
+    {
+    public void run()
+    {
+        remote_greenstone_server_authentication = new RemoteGreenstoneServerAuthenticator().getAuthentication();
+    }
+
+
+    static private class RemoteGreenstoneServerAuthenticator
+        extends GAuthenticator
+    {
+        public PasswordAuthentication getAuthentication()
+        {
+        return getPasswordAuthentication();
+        }
+
+        protected String getMessageString()
+        {
+        return Dictionary.get("RemoteGreenstoneServer.Authentication_Message");
+        }
+    }
+    }
+
+
+    static private void authenticateUser()
+    throws RemoteGreenstoneServerActionCancelledException
+    {
+    // If we don't have any authentication information then ask for it now
+    if (remote_greenstone_server_authentication == null) {
+        try {
+        // We have to do this on the GUI thread
+        SwingUtilities.invokeAndWait(new RemoteGreenstoneServerAuthenticateTask());
+        }
+        catch (Exception exception) {
+        DebugStream.printStackTrace(exception);
+        }
+
+        // If it is still null then the user has cancelled the authentication, so the action is cancelled
+        if (remote_greenstone_server_authentication == null) {
+        throw new RemoteGreenstoneServerActionCancelledException();
+        }
+    }
+    }
+
+
+    // ----------------------------------------------------------------------------------------------------
+    //   REQUEST LAYER
+    // ----------------------------------------------------------------------------------------------------
+
+
+    /** Returns the command output if the action completed, throws some kind of exception otherwise. */
+    static private String downloadFile(String gliserver_args, String file_path)
+    throws Exception
+    {
+    while (true) {
+        // Check that Configuration.gliserver_url is set
+        if (Configuration.gliserver_url == null) {
+        throw new Exception("Empty gliserver URL: please set this in Preferences before continuing.");
+        }
+
+        // Ask for authentication information (if necessary), then perform the action
+        authenticateUser();
+        String gliserver_url_string = Configuration.gliserver_url.toString();
+        String command_output = downloadFileInternal(gliserver_url_string, gliserver_args, file_path);
+
+        // Check the first line to see if authentication has failed; if so, go around the loop again
+        if (command_output.startsWith("ERROR: Authentication failed:")) {
+        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("RemoteGreenstoneServer.Error", command_output.substring("ERROR: ".length())), Dictionary.get("RemoteGreenstoneServer.Error_Title"), JOptionPane.ERROR_MESSAGE);
+        remote_greenstone_server_authentication = null;
+        continue;
+        }
+        // Check if the collection is locked by someone else; if so, see if the user wants to steal the lock
+        else if (command_output.startsWith("ERROR: Collection is locked by: ")) {
+        if (JOptionPane.showConfirmDialog(Gatherer.g_man, Dictionary.get("RemoteGreenstoneServer.Steal_Lock_Message", command_output.substring("ERROR: Collection is locked by: ".length())), Dictionary.get("RemoteGreenstoneServer.Error_Title"), JOptionPane.YES_NO_OPTION) == JOptionPane.NO_OPTION) {
+            // The user has decided to cancel the action
+            throw new RemoteGreenstoneServerActionCancelledException();
+        }
+
+        // The user has decided to steal the lock... rerun the command with "&steal_lock="
+        gliserver_args += "&steal_lock=";
+        continue;
+        }
+        // Handle other types of errors by throwing an exception
+        else if (command_output.startsWith("ERROR: ")) {
+        throw new Exception(command_output.substring("ERROR: ".length()));
+        }
+
+        // There were no exceptions thrown so the action must have succeeded
+        return command_output;
+    }
+    }
+
+
+    /** Returns the command output if the action completed, throws some kind of exception otherwise. */
+    static private String sendCommandToServer(String gliserver_args, GShell shell)
+    throws Exception
+    {
+    while (true) {
+        // Check that Configuration.gliserver_url is set
+        if (Configuration.gliserver_url == null) {
+        throw new Exception("Empty gliserver URL: please set this in Preferences before continuing.");
+        }
+
+        // Ask for authentication information (if necessary), then perform the action
+        authenticateUser();
+        String gliserver_url_string = Configuration.gliserver_url.toString();
+        String command_output = sendCommandToServerInternal(gliserver_url_string, gliserver_args, shell);
+        // System.err.println("Command output: " + command_output);
+
+        // Check the first line to see if authentication has failed; if so, go around the loop again
+        if (command_output.startsWith("ERROR: Authentication failed:")) {
+        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("RemoteGreenstoneServer.Error", command_output.substring("ERROR: ".length())), Dictionary.get("RemoteGreenstoneServer.Error_Title"), JOptionPane.ERROR_MESSAGE);
+        remote_greenstone_server_authentication = null;
+        continue;
+        }
+        // Check if the collection is locked by someone else; if so, see if the user wants to steal the lock
+        else if (command_output.startsWith("ERROR: Collection is locked by: ")) {
+        if (JOptionPane.showConfirmDialog(Gatherer.g_man, Dictionary.get("RemoteGreenstoneServer.Steal_Lock_Message", command_output.substring("ERROR: Collection is locked by: ".length())), Dictionary.get("RemoteGreenstoneServer.Error_Title"), JOptionPane.YES_NO_OPTION) == JOptionPane.NO_OPTION) {
+            // The user has decided to cancel the action
+            throw new RemoteGreenstoneServerActionCancelledException();
+        }
+
+        // The user has decided to steal the lock... rerun the command with "&steal_lock="
+        gliserver_args += "&steal_lock=";
+        continue;
+        }
+        // Handle other types of errors by throwing an exception
+        else if (command_output.startsWith("ERROR: ")) {
+        throw new Exception(command_output.substring("ERROR: ".length()));
+        }
+
+        // There were no exceptions thrown so the action must have succeeded
+        return command_output;
+    }
+    }
+
+
+    /** Returns the command output if the action completed, throws some kind of exception otherwise. */
+    static private String uploadFile(String gliserver_args, String file_path)
+    throws Exception
+    {
+    while (true) {
+        // Check that Configuration.gliserver_url is set
+        if (Configuration.gliserver_url == null) {
+        throw new Exception("Empty gliserver URL: please set this in Preferences before continuing.");
+        }
+
+        // Ask for authentication information (if necessary), then perform the action
+        authenticateUser();
+        String gliserver_url_string = Configuration.gliserver_url.toString();
+        String command_output = uploadFileInternal(gliserver_url_string, gliserver_args, file_path);
+        // System.err.println("Command output: " + command_output);
+
+        // Check the first line to see if authentication has failed; if so, go around the loop again
+        if (command_output.startsWith("ERROR: Authentication failed:")) {
+        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("RemoteGreenstoneServer.Error", command_output.substring("ERROR: ".length())), Dictionary.get("RemoteGreenstoneServer.Error_Title"), JOptionPane.ERROR_MESSAGE);
+        remote_greenstone_server_authentication = null;
+        continue;
+        }
+        // Check if the collection is locked by someone else; if so, see if the user wants to steal the lock
+        else if (command_output.startsWith("ERROR: Collection is locked by: ")) {
+        if (JOptionPane.showConfirmDialog(Gatherer.g_man, Dictionary.get("RemoteGreenstoneServer.Steal_Lock_Message", command_output.substring("ERROR: Collection is locked by: ".length())), Dictionary.get("RemoteGreenstoneServer.Error_Title"), JOptionPane.YES_NO_OPTION) == JOptionPane.NO_OPTION) {
+            // The user has decided to cancel the action
+            throw new RemoteGreenstoneServerActionCancelledException();
+        }
+
+        // The user has decided to steal the lock... rerun the command with "&steal_lock="
+        gliserver_args += "&steal_lock=";
+        continue;
+        }
+        // Handle other types of errors by throwing an exception
+        else if (command_output.startsWith("ERROR: ")) {
+        throw new Exception(command_output.substring("ERROR: ".length()));
+        }
+
+        // There were no exceptions thrown so the action must have succeeded
+        return command_output;
+    }
+    }
+
+
+    // ----------------------------------------------------------------------------------------------------
+    //   NETWORK LAYER
+    // ----------------------------------------------------------------------------------------------------
+
+
+    /** Returns the command output if the action completed, throws some kind of exception otherwise. */
+    static private String downloadFileInternal(String download_cgi, String cgi_args, String file_path)
+    throws Exception
+    {
+    DebugStream.println("gliserver URL: " + download_cgi);
+    System.err.println("gliserver args: " + cgi_args);
+
+    // Add username and password
+    cgi_args += "&un=" + remote_greenstone_server_authentication.getUserName();
+    cgi_args += "&pw=" + new String(remote_greenstone_server_authentication.getPassword());
+
+    URL download_url = new URL(download_cgi);
+    URLConnection dl_connection = download_url.openConnection();
+    dl_connection.setDoOutput(true);
+    OutputStream dl_os = dl_connection.getOutputStream();
+
+    PrintWriter dl_out = new PrintWriter(dl_os);
+    dl_out.println(cgi_args);
+    dl_out.close();
+
+    // Download result from running cgi script
+    InputStream dl_is = dl_connection.getInputStream();
+    BufferedInputStream dl_bis = new BufferedInputStream(dl_is);
+    DataInputStream dl_dbis = new DataInputStream(dl_bis);
+
+    String first_line = "";
+    byte[] buf = new byte[1024];
+    int len = dl_dbis.read(buf);
+    if (len >= 0) {
+        String first_chunk = new String(buf, 0, len);
+        first_line = first_chunk.substring(0, ((first_chunk.indexOf("\n") != -1) ? first_chunk.indexOf("\n") : len));
+
+        // Save the data to file
+        FileOutputStream zip_fos = new FileOutputStream(file_path);
         BufferedOutputStream zip_bfos = new BufferedOutputStream(zip_fos);
-        
-        byte[] buf = new byte[1024];
-        int len;
-
-        while ((len = dl_dbis.read(buf)) >= 0 && !source.hasSignalledStop()) {
-        zip_bfos.write(buf,0,len);
-        }
-
-        dl_dbis.close();
-        dl_bis.close();
-        dl_is.close();
+
+        while (len >= 0) {
+        zip_bfos.write(buf, 0, len);
+        len = dl_dbis.read(buf);
+        }
 
         zip_bfos.close();
         zip_fos.close();
-
-        if(source.hasSignalledStop()) {
-        //A cancel has been called. Delete the zip file.
-        DebugStream.println("download_url_zip() cancelled. Cleaning up.");
-        if(new File(zip_fname).delete()) {
-            DebugStream.println("Zip file " + zip_fname + " deleted");
+    }
+
+    dl_dbis.close();
+    dl_bis.close();
+    dl_is.close();
+    return first_line;
+    }
+
+
+    /** Returns the command output if the action completed, throws some kind of exception otherwise. */
+    static private String sendCommandToServerInternal(String gliserver_url_string, String cgi_args, GShell shell)
+    throws Exception
+    {
+    DebugStream.println("gliserver URL: " + gliserver_url_string);
+    System.err.println("gliserver args: " + cgi_args);
+
+    // Add username and password
+    cgi_args += "&un=" + remote_greenstone_server_authentication.getUserName();
+        cgi_args += "&pw=" + new String(remote_greenstone_server_authentication.getPassword());
+
+    URL gliserver_url = new URL(gliserver_url_string + "?" + cgi_args);
+    URLConnection gliserver_connection = gliserver_url.openConnection();
+
+    // Read the output of the command from the server, and return it
+    StringBuffer command_output_buffer = new StringBuffer(2048);
+    InputStream gliserver_is = gliserver_connection.getInputStream();
+    BufferedReader gliserver_in = new BufferedReader(new InputStreamReader(gliserver_is, "UTF-8"));
+    String gliserver_output_line = gliserver_in.readLine();
+    while (gliserver_output_line != null) {
+        if (shell != null) {
+        shell.fireMessage(gliserver_output_line);
+        if (shell.hasSignalledStop()) {
+            throw new RemoteGreenstoneServerActionCancelledException();
         }
-        else {
-            DebugStream.println("Zip file " + zip_fname + " NOT deleted (no big deal). Does it exist?");
-        }
-        }
-    }
-    catch (Exception error) {
-        error.printStackTrace();
-    }
-    DebugStream.println("Exited download_url_zip");
-    }
-
-
-    static public void upload_url_zip(String col_name, String dir, String delete_type, GShell source)
-    {
-    final String lineEnd = "\r\n";
-    final String twoHyphens = "--";
-    final String boundary =  "*****";
+        }
+        command_output_buffer.append(gliserver_output_line + "\n");
+        gliserver_output_line = gliserver_in.readLine();
+    }
+    gliserver_in.close();
+
+    return command_output_buffer.toString();
+    }
+
+
+    /** Returns the command output if the action completed, throws some kind of exception otherwise. */
+    static private String uploadFileInternal(String upload_cgi, String cgi_args, String file_path)
+    throws Exception
+    {
+    DebugStream.println("gliserver URL: " + upload_cgi);
+    System.err.println("gliserver args: " + cgi_args);
+
+    // Add username and password
+    cgi_args += "&un=" + remote_greenstone_server_authentication.getUserName();
+    cgi_args += "&pw=" + new String(remote_greenstone_server_authentication.getPassword());
+
+    // Open a HTTP connection to the URL
+    URL url = new URL(upload_cgi);
+    HttpURLConnection gliserver_connection = (HttpURLConnection) url.openConnection();
+
+    gliserver_connection.setDoInput(true);         // Allow Inputs
+    gliserver_connection.setDoOutput(true);        // Allow Outputs
+    gliserver_connection.setUseCaches(false);      // Don't use a cached copy.
+
+    gliserver_connection.setRequestProperty("Connection", "Keep-Alive");        
+
+    DataOutputStream dos = new DataOutputStream(gliserver_connection.getOutputStream());
+    dos.writeBytes(cgi_args + "\n");
+
+    // Send zip file to server
+    File file = new File(file_path);
+    FileInputStream fileInputStream = new FileInputStream(file);
+
+    // create a buffer of maximum size
     final int maxBufferSize = 1024;
-
-    String col_dir;
-    if (col_name.startsWith("/")) {
-        col_dir = Configuration.gsdl_path;
-    }
-    else {
-        col_dir = Gatherer.getCollectDirectoryPath();
-    }
-
-    String zip_fname = col_dir + col_name + ".zip";
-    String upload_cgi = Gatherer.cgiBase + "upload";
-
-    HttpURLConnection conn = null;
-
-    try {
-        // Send zip file to server
-        File file = new File(zip_fname);
-        FileInputStream fileInputStream = new FileInputStream(file);
-
-        // open a URL connection to the Servlet 
-        URL url = new URL(upload_cgi);
-        System.err.println("**** Uploading to: " + upload_cgi);
-
-        // Open a HTTP connection to the URL
-        conn = (HttpURLConnection) url.openConnection();
-
-        conn.setDoInput(true);         // Allow Inputs
-        conn.setDoOutput(true);        // Allow Outputs
-        conn.setUseCaches(false);      // Don't use a cached copy.
-        conn.setRequestMethod("POST"); // Use a post method.
-
-        conn.setRequestProperty("Connection", "Keep-Alive");        
-        conn.setRequestProperty("Content-Type", "multipart/form-data;boundary="+boundary);
-
-        DataOutputStream dos = new DataOutputStream( conn.getOutputStream() );
-
-        dos.writeBytes(twoHyphens + boundary + lineEnd);
-        dos.writeBytes("Content-Disposition: form-data; name=\"c\"" + lineEnd + lineEnd);
-        dos.writeBytes(col_name + lineEnd);
-        System.err.println("**** c="+col_name);
-
-        dos.writeBytes(twoHyphens + boundary + lineEnd);
-        dos.writeBytes("Content-Disposition: form-data; name=\"dir\"" + lineEnd + lineEnd);
-        dos.writeBytes(dir + lineEnd);  
-        System.err.println("**** dir="+dir);
-    
-        dos.writeBytes(twoHyphens + boundary + lineEnd);
-        dos.writeBytes("Content-Disposition: form-data; name=\"del\"" + lineEnd + lineEnd);
-        dos.writeBytes(delete_type + lineEnd);  
-        System.err.println("**** del="+delete_type);
-
-        dos.writeBytes(twoHyphens + boundary + lineEnd);
-        dos.writeBytes("Content-Disposition: form-data; name=\"zip\";"
-               + " filename=\"" + zip_fname +"\"" + lineEnd);
-        dos.writeBytes(lineEnd);
-        System.err.println("**** zip (filename)="+zip_fname);
-
-        // create a buffer of maximum size                  
-        int bytesAvailable = fileInputStream.available();
-        int bufferSize = Math.min(bytesAvailable, maxBufferSize);
-        byte[] buffer = new byte[bufferSize];
-        
-        // read file and write it into form...
-        int bytesRead = fileInputStream.read(buffer, 0, bufferSize);
-
-        while (bytesRead > 0) {
-        // Check to see if action has been cancelled.
-        if (source != null && source.hasSignalledStop()) {
-            break;
-        }
-        dos.write(buffer, 0, bufferSize);
-        bytesAvailable = fileInputStream.available();
-        bufferSize = Math.min(bytesAvailable, maxBufferSize);
-        bytesRead = fileInputStream.read(buffer, 0, bufferSize);
-        }
-        
-        // send multipart form data necesssary after file data...
-        
-        dos.writeBytes(lineEnd);
-        dos.writeBytes(twoHyphens + boundary + twoHyphens + lineEnd);
-        
-        // close streams
-        
-        fileInputStream.close();
-        dos.flush();
-        dos.close();
-
-        // delete zip file
-        boolean file_deleted = file.delete();
-        if (file_deleted) {
-        System.err.println("Zip file " + file.toString() + " deleted");
-        }
-        else {
-        System.err.println("Zip file " + file.toString() + " NOT deleted");
-        }
-    }
-    catch (MalformedURLException ex) {
-        System.err.println("Failed on: "+ex);
-    }
-    
-    catch (IOException ioe) {
-        System.err.println("Failed on: "+ioe);
-    }
-    
-    // Read server response
-    try {
-        InputStreamReader isr = new InputStreamReader(conn.getInputStream() );
-        BufferedReader bisr = new BufferedReader (isr);
-        String str;
-        while (( str = bisr.readLine()) != null) {
-        System.err.println(str);
-        }
-        bisr.close();
-        
-    }
-    catch (IOException ioex) {
-        System.err.println("From (ServerResponse): "+ioex);
-    }
+    int bytesAvailable = fileInputStream.available();
+    int bufferSize = Math.min(bytesAvailable, maxBufferSize);
+    byte[] buffer = new byte[bufferSize];
+
+    // read file and write it into form...
+    int bytesRead = fileInputStream.read(buffer, 0, bufferSize);
+    while (bytesRead > 0) {
+        dos.write(buffer, 0, bufferSize);
+        bytesAvailable = fileInputStream.available();
+        bufferSize = Math.min(bytesAvailable, maxBufferSize);
+        bytesRead = fileInputStream.read(buffer, 0, bufferSize);
+    }
+
+    // close streams
+    fileInputStream.close();
+    dos.flush();
+    dos.close();
+
+    // Read the output of the command from the server, and return it
+    String command_output = "";
+    InputStream gliserver_is = gliserver_connection.getInputStream();
+    BufferedReader gliserver_in = new BufferedReader(new InputStreamReader(gliserver_is, "UTF-8"));
+    String gliserver_output_line = gliserver_in.readLine();
+    while (gliserver_output_line != null) {
+        command_output += gliserver_output_line + "\n";
+        gliserver_output_line = gliserver_in.readLine();
+    }
+    gliserver_in.close();
+
+    return command_output;
+    }
+
+
+    // ----------------------------------------------------------------------------------------------------
+    //   UTILITIES
+    // ----------------------------------------------------------------------------------------------------
+
+
+    static private String getPathRelativeToDirectory(File file, String directory_path)
+    {
+    String file_path = file.getAbsolutePath();
+    if (!file_path.startsWith(directory_path)) {
+        System.err.println("ERROR: File path " + file_path + " is not a child of " + directory_path);
+        return file_path;
+    }
+
+    String relative_file_path = file_path.substring(directory_path.length());
+    if (relative_file_path.startsWith(File.separator)) {
+        relative_file_path = relative_file_path.substring(File.separator.length());
+    }
+    return relative_file_path;
     }
 }