Menu
▾
▴
[Cogkit-svn] SF.net SVN: cogkit:[2067] trunk/current/src/cog/modules/transfer-gui/src/ org/globus
|
From: <li...@us...> - 2008-07-17 05:48:57
|
Revision: 2067
http://cogkit.svn.sourceforge.net/cogkit/?rev=2067&view=rev
Author: liuwt
Date: 2008-07-17 05:48:54 +0000 (Thu, 17 Jul 2008)
Log Message:
-----------
OGCE classes which have been modified
Added Paths:
-----------
trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/
trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/
trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/
trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/
trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/FileTransferMainPanel.java
trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/monitor/
trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/monitor/UrlCopyPanel.java
trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/remote/
trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/remote/gridftp/
trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/remote/gridftp/GridClient.java
trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/transfer/
trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/transfer/FileRequest.java
Added: trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/FileTransferMainPanel.java
===================================================================
--- trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/FileTransferMainPanel.java (rev 0)
+++ trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/FileTransferMainPanel.java 2008-07-17 05:48:54 UTC (rev 2067)
@@ -0,0 +1,741 @@
+package org.globus.ogce.beans.filetransfer.gui;
+
+import org.apache.log4j.Logger;
+import org.globus.ogce.beans.filetransfer.FtpProperties;
+import org.globus.ogce.beans.filetransfer.gui.local.DirEvent;
+import org.globus.ogce.beans.filetransfer.gui.local.DirListener;
+import org.globus.ogce.beans.filetransfer.gui.local.LocalTreePanel;
+import org.globus.ogce.beans.filetransfer.gui.monitor.MonitorPanel;
+import org.globus.ogce.beans.filetransfer.gui.monitor.QueuePanel;
+import org.globus.ogce.beans.filetransfer.gui.remote.common.DisplayInterface;
+import org.globus.ogce.beans.filetransfer.gui.remote.ftp.FtpClient;
+import org.globus.ogce.beans.filetransfer.gui.remote.ftp.FtpDirEvent;
+import org.globus.ogce.beans.filetransfer.gui.remote.ftp.FtpDirListener;
+import org.globus.ogce.beans.filetransfer.gui.remote.gridftp.GridClient;
+import org.globus.ogce.beans.filetransfer.gui.remote.gridftp.RemDirEvent;
+import org.globus.ogce.beans.filetransfer.gui.remote.gridftp.RemDirListener;
+import org.globus.ogce.beans.filetransfer.transfer.DirTransferRequest;
+import org.globus.ogce.beans.filetransfer.transfer.FileRequest;
+import org.globus.ogce.beans.filetransfer.transfer.RFTFileTransfer;
+import org.globus.ogce.beans.filetransfer.transfer.UrlCopyFileTransfer;
+import org.globus.ogce.beans.filetransfer.util.DirQueue;
+import org.globus.ogce.beans.filetransfer.util.FileOperations;
+import org.globus.ogce.beans.filetransfer.util.GridBrokerQueue;
+import org.globus.ogce.beans.filetransfer.util.MessagePanel;
+import org.globus.rft.generated.TransferType;
+import org.globus.tools.ui.util.UITools;
+import org.globus.transfer.reliable.client.RFTClient;
+import org.globus.transfer.reliable.client.RFTJob;
+import org.globus.transfer.reliable.client.RFTOptions;
+import org.globus.transfer.reliable.client.RFTTransferParam;
+import org.globus.transfer.reliable.client.utils.Utils;
+import org.globus.util.ConfigUtil;
+
+import javax.swing.*;
+import javax.swing.event.InternalFrameAdapter;
+import javax.swing.event.InternalFrameEvent;
+import java.awt.*;
+import java.beans.PropertyVetoException;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.Hashtable;
+import java.util.Properties;
+
+/**
+ * This is a panel that integrates the LocalTreeBean and RemoteTreeBean to
+ * demonstrate the use of grid gui beans in the design of composite beans
+ * that provide File Transfer in Grids with drag and drop functionality.
+ *
+ * @author Beulah Kurian Alunkal
+
+ */
+public class FileTransferMainPanel extends MainInterface
+ implements DirListener,
+ RemDirListener, FtpDirListener, Serializable {
+ public static FileTransferMainPanel mainPanel = new FileTransferMainPanel(true);
+ private static Logger logger =
+ Logger.getLogger(FileTransferMainPanel.class.getName());
+ protected String defaultDir = ConfigUtil.globus_dir;
+ protected LocalTreePanel frame1[];
+ protected DisplayInterface frame2[];
+
+ //Counters are used to allow the users to add any no of local or remote
+ //file browser beans.
+ protected int remCounter = 0;
+ protected int lclCounter = 0;
+ private JFrame sFrame = null, mFrame = null;
+
+
+ //Hashtables to retrive the ftp clients selected.
+ public Hashtable gridIFTable,ftpIFTable;
+ protected boolean draglocal;
+
+ //Queues for storing the requests.
+ protected GridBrokerQueue mainQueue = null;
+ protected GridBrokerQueue requestQueue = null;
+ protected DirQueue saveQueue = null;
+
+ protected DisplayInterface fromRemote = null;
+ protected LocalTreePanel fromLocal = null;
+ protected RFTFileTransfer rftFileTransfer = null;
+ protected UrlCopyFileTransfer urlcopyFileTransfer = null;
+ protected FileRequest fileRequest = null;
+ protected MonitorPanel monitorPanel = null;
+ String from = null;
+
+ protected JPanel panel = null;
+ DirTransferRequest dirRequest = null;
+ int maxSites = 10;
+ //Parameters for bookmark.
+ String profile, user, host, pass;
+ int port = 0;
+ int scH = 0, scW = 0;
+ JDesktopPane desktop = null;
+ protected JInternalFrame messageFrame;
+ protected MessagePanel messagePanel = null;
+
+
+ //RFT transfer
+ int jobID = 0;
+ private QueuePanel queuePanel = null;
+ private RFTClient rftClient = null;
+ private static int transferID = 1;
+
+
+ /*In general for a bean default constructor*/
+ public FileTransferMainPanel() {
+ init();
+ setLayout(new GridLayout(1, 1));
+ //add(monitorPanel);
+ }
+ /*Static variable uses this contructor to create a hidden bean*/
+
+ public FileTransferMainPanel(boolean val) {
+ init();
+ sFrame = new JFrame("Status Window");
+ sFrame.getContentPane().setLayout(new GridLayout(1, 1));
+ sFrame.getContentPane().add(monitorPanel);
+ sFrame.pack();
+ sFrame.setSize(350, 400);
+ sFrame.setVisible(false);
+ UITools.center(this,sFrame);
+
+ mFrame = new JFrame("Messages Window");
+ mFrame.getContentPane().setLayout(new GridLayout(1, 1));
+ mFrame.getContentPane().add(messagePanel);
+ mFrame.pack();
+ mFrame.setSize(350, 400);
+ mFrame.setVisible(false);
+ }
+
+ public void showStatusWindow() {
+ sFrame.setVisible(true);
+ }
+
+ public void showMessagesWindow() {
+ mFrame.setVisible(true);
+ }
+ /* Normal constructor used by all graphical interfaces */
+ public FileTransferMainPanel(String label) {
+ init();
+ }
+
+ public void init() {
+ // setBorder(new TitledBorder(new BevelBorder(BevelBorder.LOWERED),""));
+ Dimension dimension = Toolkit.getDefaultToolkit().getScreenSize();
+ scW = dimension.width - 90;
+ scH = dimension.height - 90 * 2;
+ setBounds(0, 0, scW + 50, scH);
+ System.out.println("Creating a File Transfer Listener");
+ // this.panel = panel;
+ // this.desktop = desktop;
+ desktop = new JDesktopPane();
+ gridIFTable = new Hashtable();
+ ftpIFTable = new Hashtable();
+
+ mainQueue = new GridBrokerQueue();
+ requestQueue = new GridBrokerQueue();
+ saveQueue = new DirQueue();
+
+ frame1 = new LocalTreePanel[maxSites];
+ frame2 = new DisplayInterface[maxSites];
+
+ createInitialFrames();
+ rftFileTransfer = new RFTFileTransfer(this, monitorPanel);
+ urlcopyFileTransfer = new UrlCopyFileTransfer(this, monitorPanel);
+ fileRequest = new FileRequest(requestQueue, monitorPanel);
+ System.out.println("Adding Creating a File Transfer Listener");
+ desktop.putClientProperty("JDesktopPane.dragMode", "outline");
+ }
+
+ public JPanel createMonitorPanel() {
+ return monitorPanel;
+ }
+
+ protected void createInitialFrames() {
+ JInternalFrame mFrame = new JInternalFrame(
+ "Monitor Frame"
+ , true, false, true, true);
+ mFrame.setVisible(true);
+ mFrame.getContentPane().setLayout(new GridLayout(1, 1));
+ monitorPanel = new MonitorPanel(this);
+ mFrame.getContentPane().add(monitorPanel);
+ mFrame.pack();
+ mFrame.setSize(350, 330);
+ //dimensionnew.width / 5 - 30, dimensionnew.height - 95);
+ mFrame.setLocation(5, 10);
+
+ desktop.add(mFrame);
+
+ createNewLocalFrame();
+
+ String newline = new String(System.getProperty("line.separator"));
+ String msgTxt = new String("File Transfer Component"+ newline +
+ "Here the Server messages be shown"
+ + newline);
+
+
+ messageFrame = new JInternalFrame(
+ "Message Window"
+ , true, false, true, true);
+ messageFrame.setVisible(true);
+
+ messageFrame.getContentPane().setLayout(new GridLayout(1, 1));
+ messagePanel = new MessagePanel(msgTxt);
+ messageFrame.getContentPane().add(messagePanel);
+ messageFrame.pack();
+ messageFrame.setLocation(5, 340);
+ messageFrame.setSize(350, 135);
+ //messageFrame.setVisible(true);
+ desktop.add(messageFrame);
+
+ rftClient = new RFTClient(null, monitorPanel.getUrlCopyPanel().getQueuePanel());
+
+ }
+
+ public MonitorPanel getMonitorFrame() {
+ return monitorPanel;
+ }
+
+ public void processRequest() {
+ fileRequest.updateQueue(dirRequest);
+ }
+
+ public void msgOut(String s) {
+ messagePanel.msgOut(s);
+ }
+
+ public void clearQueue(String provider) {
+ logger.info("Invoked the clearQueue in main");
+ logger.info("\nPlease wait... Clearing the queues.");
+ if (provider.equals("rft")) {
+ rftFileTransfer.clearAllQueues();
+ } else if (provider.equals("urlcopy")) {
+ urlcopyFileTransfer.clearAllQueues();
+ } else {
+ fileRequest.clearRequestQueue();
+ }
+ }
+
+
+ public void controlExecutionQueue(boolean start, String provider) {
+ if (!start) {
+ JOptionPane.showMessageDialog(panel, "Will stop the job execution" +
+ " only after the current active job is done. ");
+ } else {
+ logger.info("Calling the start transfer ");
+ }
+ if (provider.equals("rft")) {
+ rftFileTransfer.setControl(start);
+ } else if (provider.equals("urlcopy")) {
+ urlcopyFileTransfer.setControl(start);
+ } else {
+ fileRequest.setControl(start);
+ }
+ }
+
+ public JDesktopPane getDesktopPane() {
+ return desktop;
+ }
+
+ public void saveQueueToFile(String provider) {
+ JFileChooser fileChooser = new JFileChooser(defaultDir);
+ fileChooser.setApproveButtonText("Save");
+ fileChooser.setDialogTitle("Save Jobs to File");
+ int popdownState = fileChooser.showSaveDialog(panel);
+ if (popdownState == JFileChooser.CANCEL_OPTION) {
+ return;
+ } else {
+ File saveFile = fileChooser.getSelectedFile();
+ //writing the default job file name into ftp.properties
+ FtpProperties props = null;
+ try {
+ props = new FtpProperties(FtpProperties.configFile);
+ if (provider.equals("rft")) {
+ props.setRFTFile(saveFile.getAbsolutePath());
+ } else {
+ props.setQueueFile(saveFile.getAbsolutePath());
+ }
+ logger.info("\nThe Queue file default location saved="
+ + props.getQueueFile());
+ props.save(FtpProperties.configFile);
+
+ } catch (Exception e) {
+ logger.debug("The system could not open the specified file\n");
+ }
+ saveQueueToFile(saveFile, provider);
+
+ }
+
+ }
+
+ public void saveQueueToFile(File saveFile, String provider) {
+ GridBrokerQueue saveQueue = null;
+ String displayString = null;
+ if (provider.equals("rft")) {
+ saveQueue = rftFileTransfer.getSaveQueue();
+ displayString = "RFT Jobs: ";
+ } else {
+ saveQueue = urlcopyFileTransfer.getSaveQueue();
+ displayString = "Local Provider Jobs: ";
+ }
+ if (saveQueue.size() > 0) {
+ int savedJobsCount = FileOperations.saveQueueToFile(saveQueue,
+ saveFile,
+ this,
+ provider);
+ JOptionPane.showMessageDialog(panel, displayString +
+ "Successfully saved " +
+ savedJobsCount + " jobs " +
+ " are not completed yet.");
+ } else {
+ JOptionPane.showMessageDialog(panel, displayString + "All jobs are done." +
+ " Nothing needs to be saved ");
+ saveFile.delete();
+ }
+ }
+
+ public void setSaveQueue(GridBrokerQueue saveQueue, String provider) {
+ if (provider.equals("rft")) {
+ rftFileTransfer.setSaveQueue(saveQueue);
+ } else {
+ urlcopyFileTransfer.setSaveQueue(saveQueue);
+ }
+ }
+
+
+ public void loadQueueFromFile(String provider) {
+ JFileChooser fileChooser = new JFileChooser(defaultDir);
+ fileChooser.setApproveButtonText("Load");
+ fileChooser.setDialogTitle("Load Jobs File");
+ int popdownState = fileChooser.showOpenDialog(panel);
+ if (popdownState == JFileChooser.CANCEL_OPTION) {
+ return;
+ } else {
+
+ File loadFile = fileChooser.getSelectedFile();
+ monitorPanel.clear(provider);
+ loadQueueFromFile(loadFile, false, provider);
+ }
+ }
+
+ public void loadQueueFromFile(File loadFile, boolean startup, String provider) {
+ FileOperations fop = new FileOperations();
+ int filesCount = fop.loadQueueFromFile(loadFile, this, provider);
+ String msg = null;
+ if (filesCount > 0) {
+ msg = "Successfully loaded " + filesCount + " jobs";
+
+ } else {
+ msg = "Trying to load an invalid file. Each line in the file should consists of fromUrl, \n" +
+ " toUrl and job id separated by semicolon. ";
+ JOptionPane.showMessageDialog(panel, msg);
+ }
+ }
+
+
+ public JPanel createNewLocalFrame() {
+ if (lclCounter >= maxSites) {
+ String msg = "You cannot open more than 10 local windows" +
+ " at the same time. \n Please close few of them" +
+ " to open new ones.";
+ JOptionPane.showMessageDialog(panel, msg);
+ return null;
+ }
+
+ frame1[lclCounter] = new LocalTreePanel("Local File System");
+ frame1[lclCounter].addDirListener(this);
+ JInternalFrame localIF = new JInternalFrame("Local System",
+ true, true, true, true);
+ localIF.setVisible(true);
+ localIF.getContentPane().setLayout(new GridLayout(1, 1));
+ localIF.getContentPane().add(frame1[lclCounter]);
+ localIF.pack();
+
+ localIF.setSize(300, 450);
+ localIF.setLocation(scW / 3 + 50 + (lclCounter) * 20,
+ 10 + (lclCounter) * 20);
+ localIF.addInternalFrameListener(new InternalFrameAdapter() {
+ public void internalFrameClosing(InternalFrameEvent e) {
+ lclCounter--;
+ System.gc();
+ }
+ });
+ desktop.add(localIF);
+ try {
+ localIF.setSelected(true);
+ } catch (PropertyVetoException propertyvetoexception1) {
+ propertyvetoexception1.printStackTrace();
+ }
+ JPanel localPanel = frame1[lclCounter];
+ System.out.println("Local count incremented.");
+ lclCounter++;
+ return localPanel;
+ }
+
+ public void registerLocalComponent(LocalTreePanel local) {
+ frame1[lclCounter] = local;
+ frame1[lclCounter].addDirListener(this);
+ lclCounter++;
+ }
+
+ public void registerRemoteComponent(DisplayInterface display, int index) {
+ if (index == 1) {
+ GridClient gc = (GridClient) display;
+ gc.addRemDirListener(this);
+ frame2[remCounter] = gc;
+ } else {
+ FtpClient fc = (FtpClient) display;
+ fc.addFtpDirListener(this);
+ frame2[remCounter] = fc;
+ }
+
+ remCounter++;
+ }
+
+ /**
+ * Creates a frame for remote file transfer client either ftp or gridftp
+ * based on the request.
+ *
+ * @param ftpindex indicates the client
+ */
+
+ public JPanel createRemoteFrame(int ftpindex, String host,
+ int port) {
+ return createRemoteFrame(ftpindex, host, port, "anonymous", "password");
+ }
+
+ public JPanel createRemoteFrame(int ftpindex, String host, int port,
+ String user, String pwd) {
+ if (remCounter >= maxSites) {
+ String msg = "You cannot open more than 10 remote windows" +
+ " at the same time. \n Please close few of them" +
+ " to open new ones.";
+ JOptionPane.showMessageDialog(panel, msg);
+ return null;
+ }
+ if (ftpindex == 1) {
+ frame2[remCounter] = new GridClient("Remote System -GridFTP ");
+ final GridClient gc = (GridClient) frame2[remCounter];
+ gc.addRemDirListener(this);
+ final JInternalFrame gridIF = new JInternalFrame(
+ "Remote System -GridFTP"
+ , true, true, true, true);
+ gridIF.setVisible(true);
+ gridIF.getContentPane().setLayout(new GridLayout(1, 1));
+ gridIF.getContentPane().add(gc);
+ gridIF.pack();
+ JFrame topLevelFrame = (JFrame)getDesktopPane().getTopLevelAncestor();
+ int frameWidth = topLevelFrame.getWidth();
+ int frameHeight = topLevelFrame.getHeight();
+ gridIF.setSize(frameWidth / 4, frameHeight / 2);
+ gridIF.setLocation((topLevelFrame.getX() + frameWidth / 5) - remCounter * 20, topLevelFrame.getY() + frameHeight / 10 + remCounter * 20);
+ //gridIF.setSize(300, 450);
+ //dimensionnew.width / 5 - 30, dimensionnew.height - 95);
+ //gridIF.setLocation(scW / 2 + 210 - (remCounter) * 20, 10 + (remCounter) * 20);
+
+
+ gridIF.addInternalFrameListener(new InternalFrameAdapter() {
+ public void internalFrameClosing(InternalFrameEvent e) {
+ gc.disconnect();
+ // gridIF = null;
+ System.gc();
+ }
+ });
+ desktop.add(gridIF);
+ try {
+ gridIF.setSelected(true);
+ } catch (PropertyVetoException propertyvetoexception1) {
+ propertyvetoexception1.printStackTrace();
+ }
+ gridIFTable.put(gc, gridIF);
+ remCounter++;
+ if (host != null) {
+ gc.setHost(host);
+ if (port != 0) {
+ gc.setPort(port);
+ }
+ if (!gc.setConnectDetails(false)) {
+ return null;
+ }
+
+ } else {
+ gc.connectDlg(null);
+ UITools.center(panel, gc.dlgConnect);
+ }
+ return gc;
+ } else if (ftpindex == 3) {
+ frame2[remCounter] = new FtpClient("Remote System -FTP");
+ final FtpClient fc = (FtpClient) frame2[remCounter];
+ fc.addFtpDirListener(this);
+ JInternalFrame ftpIF = new JInternalFrame(
+ "Remote System -FTP",
+ true, true, true, true);
+ ftpIF.getContentPane().setLayout(new GridLayout(1, 1));
+ ftpIF.getContentPane().add(fc);
+ ftpIF.pack();
+ ftpIF.setSize(300, 450);
+ //dimensionnew.width / 5 - 30, dimensionnew.height - 95);
+ ftpIF.setLocation(scW / 2 + 210 - (remCounter) * 20,
+ 10 + (remCounter) * 20);
+
+ ftpIF.addInternalFrameListener(new InternalFrameAdapter() {
+ public void internalFrameClosing(InternalFrameEvent e) {
+ fc.remoteTreeFrame._actionDisconnect();
+ // gridIF = null;
+ System.gc();
+ }
+
+ });
+ desktop.add(ftpIF);
+ try {
+ ftpIF.setSelected(true);
+ } catch (PropertyVetoException propertyvetoexception1) {
+ propertyvetoexception1.printStackTrace();
+ }
+ ftpIFTable.put(fc, ftpIF);
+ ftpIF.setVisible(true);
+ remCounter++;
+ if (host != null) {
+ fc.setHost(host);
+ if (port != 0) {
+ fc.setPort(port);
+ }
+ if (user != null) {
+ fc.setUser(user);
+ }
+ if (user != null) {
+ fc.setPwd(pwd);
+ }
+ if (!fc.setConnectDetails(false)) {
+ return null;
+ }
+ } else {
+ fc.connectDlg(null);
+ UITools.center(panel, fc.dlgConnect);
+ }
+ return fc;
+ } else {
+ logger.info("Extended Feature ");
+ return null;
+ }
+ } // end of createRemoteFrame()
+
+ /**
+ * Methods to listen to the drag and drop events.
+ *
+ */
+ public void dragLocal(DirEvent e, String from, LocalTreePanel local) {
+ String rftEnabled = Utils.getProperty("rft_enabled", "rft.properties");
+ if ("true".equals(rftEnabled)) {
+ JOptionPane.showMessageDialog(null, "RFT is enabled, you can not transfer between local machine" +
+ "and GridFTP server", "Error", JOptionPane.ERROR_MESSAGE);
+ return;
+ }
+
+ draglocal = true;
+ fromLocal = local;
+ this.from = from;
+ logger.info("Dragging Local files...");
+ }
+
+ public void dragGridFtp(RemDirEvent e, String from,
+ GridClient gc) {
+ System.out.println("dragGridFTP");
+ this.from = from;
+ draglocal = false;
+ fromRemote = gc;
+ logger.info("Dragging monitorPanel file...");
+ }
+
+ public void dragFtp(FtpDirEvent e, String from,
+ FtpClient fc) {
+ this.from = from;
+ draglocal = false;
+ fromRemote = fc;
+ logger.info("From Remote =" + fromRemote.getRootURL());
+ logger.info("Dragging Ftp file...");
+ }
+
+ public void dropLocal(DirEvent e, String to, LocalTreePanel toLocal) {
+
+ boolean dropLocal = true;
+ logger.info("Dropping the file...");
+ dirRequest = new DirTransferRequest(this,
+ fromLocal, toLocal,
+ fromRemote, null,
+ from, to,
+ draglocal, dropLocal,
+ monitorPanel.getProvider());
+
+ new AlertThread(this).start();
+
+
+ }//end of the function
+
+ public void dropGridFtp(RemDirEvent e, String to, GridClient toRemote) {
+ dirRequest = new DirTransferRequest(this,
+ fromLocal, null,
+ fromRemote, toRemote,
+ from, to,
+ draglocal, false,
+ monitorPanel.getProvider());
+
+ //----------------invode rft to transfer the file--------------------------------------
+ Properties prop = getRFTProperties("rft.properties");
+ String rftEnabled = prop.getProperty("rft_enabled");
+
+ //using RFT
+ if ("true".equals(rftEnabled)) {
+ String rftFrom = "gsiftp://" + fromRemote.getHost() + ":" + fromRemote.getPort() + from;
+ String rftTo = "gsiftp://" + toRemote.getHost() + ":" + toRemote.getPort() + to;
+ String destSN = toRemote.getSubject();
+ String sourceSN = ((GridClient)fromRemote).getSubject();
+
+ RFTTransferParam param = new RFTTransferParam(rftFrom, rftTo,
+ prop.getProperty("host"), prop.getProperty("port"));
+ int concurrent = Integer.parseInt(prop.getProperty("concurrent"));
+ int parallelStream = Integer.parseInt(prop.getProperty("parallelstream"));
+ int bufferSize = Integer.parseInt(prop.getProperty("tcpbuffersize"));
+ RFTOptions options = new RFTOptions(concurrent, parallelStream, bufferSize,
+ destSN, sourceSN);
+ RFTJob job = new RFTJob(++jobID, options, param);
+ TransferType transfer = param.getTransfers1()[0];
+ String[] cols = {Integer.toString(job.getJobID()), Integer.toString(transferID++),
+ Integer.toString(1), transfer.getSourceUrl(), transfer.getDestinationUrl(),
+ "started", "0", "No errors"};
+ monitorPanel.setFocusTab(0);
+ monitorPanel.getUrlCopyPanel().addTransfer(Integer.toString(job.getJobID()),
+ transfer.getSourceUrl(), transfer.getDestinationUrl());
+
+ try {
+ //queuePanel.addTransfer(cols);
+ rftClient.startTransfer(job);
+ } catch (Exception e1) {
+ e1.printStackTrace();
+ JOptionPane.showMessageDialog(null,e1.getMessage(), "Error",
+ JOptionPane.WARNING_MESSAGE);
+ int index = queuePanel.getRowIndex(Integer.toString(jobID));
+ queuePanel.setColumnValue(index, 5, "Failed");
+ queuePanel.setColumnValue(index, 7, e1.getMessage());
+ }
+ } else { // third party transfer
+ new AlertThread(this).start();
+ }
+
+
+
+ //----------------invoke rft end-------------------------------------------------------
+
+ }
+
+
+ public void dropFtp(FtpDirEvent e, String to, FtpClient toRemote) {
+ dirRequest = new DirTransferRequest(this,
+ fromLocal, null,
+ fromRemote, toRemote,
+ from, to,
+ draglocal, false,
+ monitorPanel.getProvider());
+ new AlertThread(this).start();
+ }
+
+ private Properties getRFTProperties(String fileName) {
+ File propFile = new File(fileName);
+ if (!propFile.exists()) {
+ return null;
+ }
+ FileInputStream fis = null;
+ Properties prop = new Properties();
+ try {
+ fis = new FileInputStream(propFile);
+ prop.load(fis);
+ } catch (Exception e) {
+ e.printStackTrace();
+ } finally {
+ try {
+ fis.close();
+ } catch (IOException e) {
+ }
+ }
+
+ return prop;
+ }
+ /**
+ * Methods to increment the counter to keep track of the no of remote
+ * clients currently active.
+ */
+ public void ftpCounter(FtpDirEvent e, FtpClient gc) {
+ if (remCounter > 0) {
+ JInternalFrame gridframe = (JInternalFrame) ftpIFTable.get(gc);
+ gridframe.setVisible(false);
+ remCounter--;
+ logger.info("\nFtp site is disconnected. ");
+ }
+
+ }
+
+ public void gridCounter(RemDirEvent e, GridClient gc) {
+ if (remCounter > 0) {
+ JInternalFrame gridframe = (JInternalFrame) gridIFTable.get(gc);
+ gridframe.setVisible(false);
+ remCounter--;
+ logger.info("\nGridFTP site is disconnected. ");
+ }
+
+ }
+
+ public void startActualTransfer(String provider) {
+ if (provider.equals("rft")) {
+ rftFileTransfer.run();
+ } else {
+ urlcopyFileTransfer.run();
+ }
+
+ }
+
+ public void startActualTransfer(GridBrokerQueue requestQueue,
+ String provider) {
+ System.out.println("TESTING : Request Queue file size=" + requestQueue.size());
+ //monitorPanel.setFocusTab(1);
+ if (provider.equals("rft")) {
+ monitorPanel.setFocusTab(1);
+ rftFileTransfer.updateQueues(requestQueue);
+ monitorPanel.setFocusTab(1);
+ } else
+ {
+ monitorPanel.setFocusTab(0);
+ urlcopyFileTransfer.updateQueues(requestQueue);
+ }
+ }
+
+ public FileTransferMainPanel(JPanel panel, JDesktopPane desktop) {
+ this();
+ }
+
+ public static void main(String args[]) {
+
+ }
+}
Added: trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/monitor/UrlCopyPanel.java
===================================================================
--- trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/monitor/UrlCopyPanel.java (rev 0)
+++ trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/monitor/UrlCopyPanel.java 2008-07-17 05:48:54 UTC (rev 2067)
@@ -0,0 +1,505 @@
+package org.globus.ogce.beans.filetransfer.gui.monitor;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.globus.io.urlcopy.UrlCopy;
+import org.globus.io.urlcopy.UrlCopyListener;
+import org.globus.ogce.beans.filetransfer.gui.MainInterface;
+import org.globus.ogce.beans.filetransfer.transfer.TransferInterface;
+import org.globus.tools.ui.util.UITools;
+import org.globus.transfer.reliable.client.utils.Utils;
+import org.globus.util.GlobusURL;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.Hashtable;
+
+public class UrlCopyPanel extends JPanel implements TransferInterface, UrlCopyListener//, ActionListener
+{
+ static Log logger =
+ LogFactory.getLog(UrlCopyPanel.class.getName());
+
+ QueuePanel urlcopyQueuePanel = null;
+ UrlCopyOptions urlcopyOptions = null;
+ Hashtable jobs = null;
+ String currentJob = null;
+ String errorMsg = null;
+ MainInterface theApp = null;
+ String finalStatus = "Unknown";
+ boolean active = false;
+
+ public UrlCopyPanel() {
+ this(null);
+ }
+
+ public UrlCopyPanel(MainInterface theApp) {
+ setLayout(new BorderLayout());
+ this.theApp = theApp;
+ urlcopyQueuePanel = new QueuePanel();
+ urlcopyQueuePanel.createHeader(new String[]{"Jobid", "From", "To",
+ "Status", "Current", "%", "Errors"});
+ add(urlcopyQueuePanel, BorderLayout.CENTER);
+ urlcopyOptions = new UrlCopyOptions();
+ // add(urlcopyOptions.getPanel(), BorderLayout.SOUTH);
+ jobs = new Hashtable();
+ //urlcopyQueuePanel.createButtonsPanel(new String[]{"Start", "Stop", "Load", "Save", "Clear"}, new ButtonActionListener());
+ urlcopyQueuePanel.addPopupItems(new String[]{"Info", "Cancel", "Restart",
+ "Delete"}, new ButtonActionListener());
+ // createCheckBoxPanel();
+
+ }
+
+ public void addTransfer(String jobid, String from, String to) {
+
+ urlcopyQueuePanel.addTransfer(new String[]{jobid, from, to, "Submitted",
+ "0", "0", "N/A"});
+
+ }
+
+ public void startTransfer(String jobid) {
+ currentJob = jobid;
+
+ if (!((isJob("Cancelled", jobid, false) || (isJob("Finished", jobid, false))))) {
+ active = true;
+ String from = urlcopyQueuePanel.getColumnValue(
+ urlcopyQueuePanel.getRowIndex(jobid), 1);
+ String to = urlcopyQueuePanel.getColumnValue(
+ urlcopyQueuePanel.getRowIndex(jobid), 2);
+ callUrlCopyTransfer(jobid, from, to);
+ active = false;
+ } else {
+ return;
+ }
+
+ }
+
+ public void updateTransfer(String jobid, String status,
+ String current, String percent, String errorMsg) {
+
+ urlcopyQueuePanel.updateTransfer(new String[]{jobid, null, null, status,
+ current, percent
+ , errorMsg});
+
+ }
+
+ public void deleteTransfer(String jobid) {
+ cancelTransfer(jobid);
+ urlcopyQueuePanel.deleteTransfer(jobid);
+ }
+
+ public void cancelTransfer(String jobid) {
+ if (isJob("Finished", jobid)) {
+ logger.info("Job Finished id = " + jobid);
+ } else {
+ logger.info("Job Finished id = " + jobid);
+ updateTransfer(jobid, "Cancelled", null, null, null);
+ UrlCopy urlcopy = (UrlCopy) jobs.get(jobid);
+ urlcopy.cancel();
+ }
+ }
+
+ public boolean callUrlCopyTransfer(String jobid, String from, String to) {
+ GlobusURL froms = null;
+ GlobusURL tos = null;
+ UrlCopy c = null;
+ if (from.equals(to)) {
+ updateTransfer(jobid, "Cancelled",
+ null, null, "Destination and Source are same.");
+ }
+ logger.info("\nJOB :: \n ID = " + jobid);
+ logger.info("\nFrom = " + from);
+ logger.info("\nTo = " + to);
+ try {
+ froms = new GlobusURL(from);
+ tos = new GlobusURL(to);
+ c = new UrlCopy();
+ c.setSourceUrl(froms);
+ c.setDestinationUrl(tos);
+
+ if (from.startsWith("gsiftp") && to.startsWith("gsiftp")) {
+ c.setUseThirdPartyCopy(true);
+ } else {
+ c.setUseThirdPartyCopy(false);
+ }
+
+ int bufferSize = Integer.parseInt(Utils.getProperty("tcpbuffersize", "rft.properties"));
+ c.setBufferSize(bufferSize);
+ c.setAppendMode(urlcopyOptions.getAppendMode());
+ c.setDCAU(urlcopyOptions.getDCAU());
+ c.addUrlCopyListener(this);
+ jobs.put(jobid, c);
+ long st = System.currentTimeMillis();
+ if (!(c.isCanceled())) {
+ printOutput("\n\n------------------------------\n");
+ printOutput("Started Job: " + jobid);
+ printOutput("\n------------------------------\n");
+ updateTransfer(currentJob, "Active",
+ null, null, "No errors");
+
+ c.copy();
+ finalStatus = "Finished";
+ updateTransfer(currentJob, "Finished",
+ null, null, "No errors");
+
+ urlcopyQueuePanel.setFocus(currentJob);
+ long ft = System.currentTimeMillis();
+ long time = ft - st;
+ printOutput("\nFrom :" + c.getSourceUrl() +
+ "\nTo :" + c.getDestinationUrl() +
+ "\nTotal time in millisec = " + time);
+
+
+ }
+ return true;
+
+ } catch (Exception te) {
+
+ String error = getStackTrace(te);
+ String errorMsg = null;
+
+ te.printStackTrace();
+ errorMsg = processErrorMessage(error);
+ if (errorMsg == null) {
+ errorMsg = te.getMessage();
+ }
+ if (errorMsg.indexOf("Root error message: null") >= 0) {
+ errorMsg = "File exists";
+ }
+ finalStatus = "Failed : " + errorMsg;
+ updateTransfer(currentJob, "Failed",
+ null, null, errorMsg);
+ urlcopyQueuePanel.setFocus(currentJob);
+ printError("\n\n\nFrom :" + c.getSourceUrl() +
+ "\nTo :" + c.getDestinationUrl() +
+ "Error during actual transfer:\n" +
+ error);
+ return false;
+
+ }
+
+
+ }
+
+ public String getFinalStatus() {
+ return finalStatus;
+ }
+
+ public QueuePanel getQueuePanel() {
+ return urlcopyQueuePanel;
+ }
+
+ public String processErrorMessage(String error) {
+ String errorMsg = null;
+ if ((error.indexOf("Permission denied")) > 0) {
+ errorMsg = "Permission denied";
+ } else if ((error.indexOf("Expired credentials"))
+ > 0) {
+ errorMsg = "Credentials expired";
+ } else if (((error.indexOf("FileNotFoundException")) > 0)
+ || ((error.indexOf("No such file or directory")) > 0)) {
+ errorMsg = "Destination Directory is not present. Please create one.";
+
+ } else if ((error.indexOf("ClassCastException"))
+ > 0) {
+ errorMsg = "Destination rejected third party transfer";
+ } else if (((error.indexOf("not enough space on the disk")) > 0) || ((error.indexOf("Disc quota exceeded")) > 0)) {
+ errorMsg = "No space in Destination Disk. ";
+ } else if ((error.indexOf("Connection reset"))
+ > 0) {
+ errorMsg = "Network Connection lost.";
+
+ } else if (((error.indexOf("Timeout")) > 0) ||
+ ((error.indexOf("timed out")) > 0) ||
+ (((error.indexOf("timeout"))) > 0)) {
+ errorMsg = "Connection Timed out. Check for firewalls. ";
+ } else if (((error.indexOf("close failed")) > 0) ||
+ (((error.indexOf("closing"))) > 0)) {
+ errorMsg = "Transfer was cancelled.";
+ }
+ return errorMsg;
+ }
+
+ Exception _exception;
+
+ public void transfer(long current, long total) {
+ long progress = 0;
+ if (total == -1) {
+ if (current == -1) {
+ printOutput("This is a third party transfer.");
+ } else {
+ logger.info("\nJOB :: \n ID = " + currentJob + " " + current);
+ }
+ } else {
+ double fraction = (double) current / (double) total;
+ float fvalue = Math.round(Math.round(fraction * 100));
+ progress = (long) fvalue;
+ logger.info("\n" + current + " out of " + total + " Percent =" + progress);
+ }
+ String currValue = "N/A";
+ String progressValue = "N/A";
+ if (progress != 0) {
+ progressValue = progress + "";
+ }
+
+ if (current > 0) {
+ currValue = current + "";
+ }
+ updateTransfer(currentJob, "Active",
+ currValue, progressValue, "No errors");
+ }
+
+ public void transferError(Exception e) {
+ _exception = e;
+
+ }
+
+ public void transferCompleted() {
+ if (_exception == null) {
+ printOutput("Transfer completed successfully");
+
+ } else {
+ printError("Error during transfer : " + _exception.getMessage());
+ logger.debug("Error during transfer : " + _exception.getMessage());
+
+ _exception.printStackTrace(System.out);
+
+ }
+ }
+
+ public JPanel getOptionsPanel() {
+ return urlcopyOptions.getPanel();
+ }
+
+ public void createCheckBoxPanel() {
+ JCheckBox allButton = new JCheckBox("All", true);
+ allButton.addItemListener(new ItemListener() {
+ public void itemStateChanged(ItemEvent e) {
+ if (e.getStateChange() == ItemEvent.DESELECTED) {
+ urlcopyQueuePanel.showRows("All", 3);
+ }
+ }
+ });
+ JCheckBox activeButton = new JCheckBox("Active");
+ JCheckBox finishedButton = new JCheckBox("Finished");
+ JCheckBox failedButton = new JCheckBox("Failed");
+ JCheckBox othersButton = new JCheckBox("Others");
+ urlcopyQueuePanel.createCheckBoxPanel(new JCheckBox[]{allButton, activeButton, finishedButton, failedButton, othersButton});
+ }
+
+ public void clear() {
+ if (urlcopyQueuePanel.tableSize() > 0) {
+ Object aobj[] = {"Yes", "No"};
+ int k = JOptionPane.showOptionDialog(null, " Do you wish to clear all the jobs and stop the unfinished jobs ?", "Cancellation Alert", -1, 2, null, aobj, aobj[0]);
+ if (k == 1) {
+ return;
+ } else {
+ if (!isJob("Finished", currentJob, false)) {
+ cancelTransfer(currentJob);
+ }
+ theApp.clearQueue("urlcopy");
+ try {
+ Thread.sleep(5000);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ urlcopyQueuePanel.clear();
+ return;
+
+ }
+ } else {
+ return;
+ }
+ }
+
+ private String getStackTrace(Exception e) {
+ StringWriter sw = new StringWriter();
+ PrintWriter pw = new PrintWriter(sw);
+ e.printStackTrace(pw);
+ return sw.toString();
+ }
+
+ public void printOutput(String msg) {
+ theApp.msgOut(msg);
+ }
+
+ public void printError(String msg) {
+ theApp.msgOut(msg);
+ }
+
+ public static void main(String args[]) {
+ JFrame frame = new JFrame("Java CoG Kit -UrlCopy File Transfer");
+
+ frame.addWindowListener(new WindowAdapter() {
+ public void windowClosing(WindowEvent e) {
+ System.exit(0);
+ }
+ });
+
+
+ Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
+
+ UrlCopyPanel urlcopyPanel = new UrlCopyPanel();
+ // frame.getContentPane().setLayout(new BorderLayout());
+ frame.getContentPane().add(urlcopyPanel);
+ // frame.getContentPane().add(urlcopyPanel.getOptionsPanel().getPanel(), BorderLayout.SOUTH);
+ frame.pack();
+ frame.setSize(d.width / 2, d.height / 2);
+ frame.setVisible(true);
+ UITools.center(null, frame);
+ for (int i = 1; i < 10; i++) {
+ urlcopyPanel.addTransfer("" + i, "gsiftp://arbat.mcs.anl.gov:6223/homes/alunkal/dead.letter", "gsiftp://arbat.mcs.anl.gov:6223/homes/alunkal/test" + i);
+ }
+ int j = 1;
+ while (j < 9) {
+ urlcopyPanel.startTransfer(j + "");
+ j++;
+ }
+
+ }
+
+ public boolean isJob(String status, String job) {
+ return isJob(status, job, true);
+ }
+
+ public boolean isJob(String status, String job, boolean alert) {
+ int row = urlcopyQueuePanel.getRowIndex(job);
+ if (row >= 0) {
+ logger.info("VALUE OF THE CURRENT JOB =" + urlcopyQueuePanel.getColumnValue(row, 3));
+ if (urlcopyQueuePanel.getColumnValue(row, 3).equals(status)) {
+ if (alert) {
+ JOptionPane.showMessageDialog(null,
+ "The job is already " + status,
+ "URLCOPY Job Information",
+ JOptionPane.PLAIN_MESSAGE);
+ }
+ return true;
+ } else {
+ return false;
+ }
+ }
+ return false;
+ }
+
+ class ButtonActionListener implements ActionListener {
+ public void actionPerformed(ActionEvent ae) {
+ String actionCommand = ae.getActionCommand();
+ if (actionCommand.equals("Save")) {
+ Thread saveThread = new Thread() {
+ public void run() {
+ if (urlcopyQueuePanel.tableSize() > 0) {
+ theApp.saveQueueToFile("urlcopy");
+ }
+ }
+ };
+ saveThread.start();
+ } else if (actionCommand.equals("Load")) {
+ Thread loadThread = new Thread() {
+ public void run() {
+ theApp.loadQueueFromFile("urlcopy");
+ }
+ };
+ loadThread.start();
+ } else if (actionCommand.equals("Stop")) {
+ Thread controlThread = new Thread() {
+ public void run() {
+ if (urlcopyQueuePanel.tableSize() > 0) {
+ theApp.controlExecutionQueue(false, "urlcopy");
+ }
+ }
+ };
+ controlThread.start();
+ } else if (actionCommand.equals("Start")) {
+ Thread controlThread = new Thread() {
+ public void run() {
+ if (urlcopyQueuePanel.tableSize() > 0) {
+ theApp.controlExecutionQueue(true, "urlcopy");
+ }
+ }
+ };
+ controlThread.start();
+ } else if (actionCommand.equals("Clear")) {
+ Thread controlThread = new Thread() {
+ public void run() {
+ if (urlcopyQueuePanel.tableSize() > 0) {
+ clear();
+ }
+ }
+ };
+ controlThread.start();
+ } else if (actionCommand.equals("Info")) {
+ String job = urlcopyQueuePanel.getSelectedJob();
+ int row = urlcopyQueuePanel.getRowIndex(job);
+ String msg = " Job ID : " +
+ urlcopyQueuePanel.getColumnValue(row, 0)
+ + "\n From : "
+ + urlcopyQueuePanel.getColumnValue(row, 1) +
+ "\n To : " +
+ urlcopyQueuePanel.getColumnValue(row, 2) +
+ "\n Status : " +
+ urlcopyQueuePanel.getColumnValue(row, 3)
+ + "\n Errors : " +
+ urlcopyQueuePanel.getColumnValue(row, 6) +
+ "\n";
+
+ JOptionPane.showMessageDialog(null,
+ msg,
+ "URLCOPY Job Information",
+ JOptionPane.PLAIN_MESSAGE);
+
+ } else if (actionCommand.equals("Cancel")) {
+ Thread controlThread = new Thread() {
+ public void run() {
+ String job = urlcopyQueuePanel.getSelectedJob();
+ cancelTransfer(job);
+
+ }
+ };
+ controlThread.start();
+
+ } else if (actionCommand.equals("Restart")) {
+ Thread controlThread = new Thread() {
+ public void run() {
+ String job = urlcopyQueuePanel.getSelectedJob();
+ if ((isJob("Cancelled", job) || (isJob("Finished", job)))) {
+ return;
+ }
+ while (active) {
+ try {
+ Thread.sleep(200);
+ logger.info("Waiting for the previous job");
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ startTransfer(job);
+ }
+ };
+ controlThread.start();
+
+ } else if (actionCommand.equals("Delete")) {
+ String job = urlcopyQueuePanel.getSelectedJob();
+ int row = urlcopyQueuePanel.getRowIndex(job);
+ if (!urlcopyQueuePanel.getColumnValue(row, 3).equals("Finished")) {
+ Object aobj[] = {"Yes", "No"};
+ int k = JOptionPane.showOptionDialog(null, " This job is not Finished yet. Do you wish to cancel the job and delete it?", "Deletion Alert", -1, 2, null, aobj, aobj[0]);
+ if (k == 1) {
+ return;
+ } else {
+ deleteTransfer(job);
+ }
+ } else {
+ deleteTransfer(job);
+ }
+
+ }
+ }
+
+ }
+
+
+}// end of class
+
+
Added: trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/remote/gridftp/GridClient.java
===================================================================
--- trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/remote/gridftp/GridClient.java (rev 0)
+++ trunk/current/src/cog/modules/transfer-gui/src/org/globus/ogce/beans/filetransfer/gui/remote/gridftp/GridClient.java 2008-07-17 05:48:54 UTC (rev 2067)
@@ -0,0 +1,1196 @@
+package org.globus.ogce.beans.filetransfer.gui.remote.gridftp;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.log4j.Logger;
+import org.globus.common.CoGProperties;
+import org.globus.ftp.*;
+import org.globus.ftp.exception.ServerException;
+import org.globus.gsi.GlobusCredential;
+import org.globus.gsi.gssapi.GlobusGSSCredentialImpl;
+import org.globus.ogce.beans.filetransfer.gui.FileTransferMainPanel;
+import org.globus.ogce.beans.filetransfer.gui.monitor.WindowProgress;
+import org.globus.ogce.beans.filetransfer.gui.remote.common.DisplayInterface;
+import org.globus.ogce.beans.filetransfer.gui.remote.common.GridEvent;
+import org.globus.ogce.beans.filetransfer.gui.remote.common.GridListener;
+import org.globus.ogce.beans.filetransfer.gui.remote.common.RemoteTreeFrame;
+import org.globus.ogce.beans.filetransfer.util.DirQueue;
+import org.globus.tools.ui.util.UITools;
+import org.ietf.jgss.GSSCredential;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.io.*;
+import java.util.Vector;
+
+
+public class GridClient extends JPanel implements PropertyChangeListener, DisplayInterface, GridListener, ActionListener, Runnable, Serializable {
+ private static Log logger = LogFactory.getLog(GridClient.class.getName());
+
+ private GridFTPClient client;
+ private GridFTPClient client1;
+ private GridFTPClient client2;
+ private GridFTPClient client3;
+ WindowProgress wndPreload = null;
+
+ private final int GRID_FTP_PORT = 2811;
+
+ public String host;
+
+ private int port;
+
+ private String profile;
+
+ private String subject = null;
+
+ public RemoteTreeFrame remoteTreeFrame;
+
+ public String remoterootDir;
+
+ public boolean isConnected = false;
+
+ public boolean busy;
+
+
+ private boolean put = false;
+
+
+ protected JTextField txtHost;
+
+ protected JTextField txtPort;
+
+ protected JTextField txtUName;
+
+ protected JTextField txtprofileName;
+
+ protected JTextField txtSubject;
+
+ public JDialog dlgConnect;
+
+ private String FileSep;
+
+ private GridBagConstraints gbc;
+
+ private DirQueue queue;
+
+ private String status = null, url = null;
+
+ private boolean bean = false;
+ protected Vector remdirlisteners = new Vector();
+
+ /** Register an action listener to be notified when a button is pressed */
+ public void addRemDirListener(RemDirListener l) {
+ remdirlisteners.addElement(l);
+ }
+
+ /** Remove an Answer listener from our list of interested listeners */
+ public void removeRemDirListener(RemDirListener l) {
+ remdirlisteners.removeElement(l);
+ }
+
+ /** Send an event to all registered listeners */
+ public void fireRemDirEvent(RemDirEvent e, DirQueue dirqueue, String path, GridClient gc) {
+ // Make a copy of the list and fire the events using that copy.
+ Vector list = (Vector) remdirlisteners.clone();
+ for (int i = 0; i < list.size(); i++) {
+ RemDirListener listener = (RemDirListener) list.elementAt(i);
+ try {
+ switch (e.getID()) {
+ case RemDirEvent.DIR:
+ listener.dropGridFtp(e, path, gc);
+ break;
+ case RemDirEvent.REMOTEDRAG:
+ listener.dragGridFtp(e, path, gc);
+ break;
+ case RemDirEvent.COUNTER:
+ listener.gridCounter(e, gc);
+ break;
+
+ }
+ } catch (Exception direx) {
+ direx.printStackTrace();
+ }
+ }
+ }
+
+ public GridClient() {
+ this(null, true);
+ bean = true;
+ FileTransferMainPanel.mainPanel.registerRemoteComponent(this, 1);
+ remoteTreeFrame.statusOut("Status: Not connected");
+ }
+
+ public GridClient(String s) {
+ this(s, false);
+ }
+
+ public GridClient(String s, boolean bean) {
+
+ remoteTreeFrame = new RemoteTreeFrame(this, bean);
+ remoteTreeFrame.setVisible(true);
+ setLayout(new GridLayout(1, 1));
+ add(remoteTreeFrame);
+ setVisible(true);
+
+ remoteTreeFrame.addPropertyChangeListener(this);
+
+ remoteTreeFrame.addGridListener(this);
+
+ txtHost = null;
+ txtPort = null;
+ host = null;
+ port = GRID_FTP_PORT;
+ FileSep = null;
+
+ isConnected = false;
+ dlgConnect = null;
+ gbc = new GridBagConstraints();
+ queue = new DirQueue();
+ remoteTreeFrame.setProtocol("gsiftp");
+ remoteTreeFrame.setPort(GRID_FTP_PORT);
+ }
+
+ public String getStatus() {
+ return status;
+ }
+
+ public String getUrl() {
+ return url;
+ }
+
+ public void setStatus(String status) {
+ this.status = status;
+ remoteTreeFrame.statusOut(status);
+ }
+
+ public void setUrl(String url) {
+ this.url = url;
+ remoteTreeFrame.setUrl(url);
+ }
+
+ public void connectDlg(JFrame frame) {
+ if (isConnected) {
+ remoteTreeFrame.statusOut("Connection Exists");
+ return;
+ }
+ remoteTreeFrame.statusOut("Please wait. Connecting");
+ dlgConnect = new JDialog(frame);
+ System.out.println("dlgConnect");
+ dlgConnect.setTitle("Connect to GridFTP");
+ UITools.center(frame, dlgConnect);
+ dlgConnect.addWindowListener(new WindowAdapter() {
+ public void windowClosing(WindowEvent windowevent) {
+ windowevent.getWindow().dispose();
+ System.gc();
+ dlgConnect.removeAll();
+ remoteTreeFrame.setConnected(false);
+ }
+ });
+ txtHost = new JTextField(20);
+ txtHost.setFont(new Font("Times New Roman", 0, 15));
+ txtprofileName = new JTextField(20);
+ txtprofileName.setText(GRID_FTP_PORT + "");
+ txtprofileName.setFont(new Font("Times New Roman", 0, 15));
+ txtSubject = new JTextField(20);
+ txtSubject.setFont(new Font("Times New Roman", 0, 15));
+ JLabel jhost = new JLabel("Host ");
+ JLabel jprofile = new JLabel("Port ");
+ JLabel jsubject = new JLabel("Subject ");
+ JButton jbutton = new JButton("ok");
+ jbutton.addActionListener(this);
+ jbutton.setActionCommand("10");
+ JButton jbutton1 = new JButton("cancel");
+ jbutton1.addActionListener(this);
+ jbutton1.setActionCommand("11");
+ JPanel jpanel4 = new JPanel();
+ jpanel4.add(jbutton);
+ jpanel4.add(jbutton1);
+
+ Container container = dlgConnect.getContentPane();
+ container.setLayout(new BorderLayout());
+ JPanel jp = new JPanel();
+ jp.setLayout(new GridBagLayout());
+ jp.setPreferredSize(new Dimension(350, 200));
+
+ jp.add(jhost, getGBC(0, 16, 0.300000000000000000, 1.0, 0, 2, 1, 2));
+ jp.add(txtHost, getGBC(0, 16, 0.7000000000000000, 0.0, 1, 3, 4, 1));
+ jp.add(jprofile, getGBC(0, 16, 0.30000000000000000, 1.0, 0, 4, 1, 2));
+ jp.add(txtprofileName, getGBC(0, 16, 0.70000000000000000, 0.0, 1, 5, 4, 1));
+ jp.add(jsubject, getGBC(0, 16, 0.30000000000000000, 1.0, 0, 6, 1, 2));
+ jp.add(txtSubject, getGBC(0, 16, 0.70000000000000000, 0.0, 1, 7, 4, 1));
+ jp.add(jpanel4, getGBC(0, 16, 0.30000000000000000, 1.0, 1, 8, 4, 1));
+ container.add(jp, BorderLayout.CENTER);
+
+ txtHost.addKeyListener(new KeyAdapter() {
+ public void keyTyped(KeyEvent keyevent) {
+ char c = keyevent.getKeyChar();
+ if (c == '\n') {
+ txtprofileName.requestFocus();
+ }
+ }
+ });
+ txtprofileName.addKeyListener(new KeyAdapter() {
+ public void keyTyped(KeyEvent keyevent) {
+ remoteTreeFrame.statusOut("Please wait. Connecting");
+ char c = keyevent.getKeyChar();
+ if (c == '\n') {
+ doConnectOK();
+ }
+ }
+ });
+
+ dlgConnect.pack();
+ dlgConnect.setVisible(true);
+ dlgConnect.show();
+
+ }
+
+ protected GridBagConstraints getGBC(int i, int j, double d, double d1, int k, int l, int i1, int j1) {
+ gbc.fill = i;
+ gbc.anchor = j;
+ gbc.weightx = d;
+ gbc.weighty = d1;
+ gbc.gridx = k;
+ gbc.gridy = l;
+ gbc.gridwidth = i1;
+ gbc.gridheight = j1;
+ return gbc;
+ }
+
+ public void doConnectOK() {
+
+ dlgConnect.setVisible(false);
+ dlgConnect.dispose();
+ dlgConnect.removeAll();
+ dlgConnect = null;
+ System.gc();
+ wndPreload = new WindowProgress("Connecting ... Please wait", 25);
+ centerWindow(wndPreload);
+ // wndPreload.setVisible(true);
+ wndPreload.setProgressValue(5);
+ try {
+ port = Integer.parseInt(txtprofileName.getText());
+ } catch (Exception e) {
+ e.printStackTrace(System.out);
+ remoteTreeFrame.setConnected(false);
+ }
+
+ host = txtHost.getText();
+ subject = txtSubject.getText();
+ profile = host + ":" + port;//txtprofileName.getText();
+ if (profile.length() <= 0) {
+ profile = host;
+ }
+ wndPreload.setProgressValue(8);
+ setConnectDetails(true);
+ }
+
+ public boolean setConnectDetails(boolean interactive) {
+ remoteTreeFrame.setProtocol("gsiftp");
+ remoteTreeFrame.setHost(host);
+ remoteTreeFrame.setPort(port);
+ if (wndPreload != null) {
+ wndPreload.setProgressValue(10);
+ }
+ final boolean isInteractive = interactive;
+ Thread connectThread = new Thread(){
+ public void run(){
+ remoteTreeFrame._actionConnect(isInteractive);
+ }
+ };
+ connectThread.start();
+ if (wndPreload != null) {
+ wndPreload.setProgressValue(24);
+ }
+ if (wndPreload != null) {
+ wndPreload.setProgressValue(25);
+ wndPreload.setVisible(false);
+
+ wndPreload = null;
+ }
+ if (isConnected) {
+ return t...
[truncated message content] |
