src/java/org/apache/log4j/chainsaw/vfs/VFSPlugin.java

package org.apache.log4j.chainsaw.vfs;

import java.awt.BorderLayout;
import java.awt.Cursor;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.io.File;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import javax.swing.JPopupMenu;
import javax.swing.JSplitPane;
import javax.swing.JTree;
import javax.swing.ProgressMonitorInputStream;
import javax.swing.SwingUtilities;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;

import org.apache.commons.vfs.FileObject;
import org.apache.commons.vfs.FileSystemException;
import org.apache.commons.vfs.VFS;
import org.apache.commons.vfs.impl.StandardFileSystemManager;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.apache.log4j.chainsaw.PopupListener;
import org.apache.log4j.chainsaw.messages.MessageCenter;
import org.apache.log4j.chainsaw.plugins.GUIPluginSkeleton;

/**
 * GUI interface to the Jarkata Commons VFS project.
 * 
 * This is currently a Work In Progress
 * 
 * @see http://jakarta.apache.org/commons/
 * 
 * @author psmith
 *  
 */
public class VFSPlugin extends GUIPluginSkeleton {

    private static final Logger USER_MESSAGE_LOGGER = MessageCenter
            .getInstance().getLogger();

    private final FileSystemTreePanel fileSystemTree = new FileSystemTreePanel();

    private final FileObjectTable fileObjectTable = new FileObjectTable();

    private final JSplitPane splitPane = new JSplitPane();

    private final PreviewPanel previewPane = new PreviewPanel();

    private final JSplitPane rightSplit = new JSplitPane(
            JSplitPane.VERTICAL_SPLIT);

    private VFSPluginPreferenceModel prefModel;

    private StandardFileSystemManager fileSystemManager;

    private final AOFileTablePopulater aoTablePopulator = new AOFileTablePopulater(
            fileObjectTable.getTableModel());

    private final AOChildDirectorScanner aoDirectoryScanner = new AOChildDirectorScanner();

    private Set supportedSchemes = new HashSet();
    
    private final Logger logger = LogManager.getLogger(VFSPlugin.class);

    public VFSPlugin() {
        setName("VFS");
        initGUI();
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.apache.log4j.plugins.Plugin#shutdown()
     */
    public void shutdown() {
        if (fileSystemManager != null) {
            fileSystemManager.close();
        }
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.apache.log4j.spi.OptionHandler#activateOptions()
     */
    public void activateOptions() {
        try {
            this.fileSystemManager = (StandardFileSystemManager) VFS
                    .getManager();

            //            TODO load the pref model from preference storage
            this.prefModel = new VFSPluginPreferenceModel();

        } catch (FileSystemException e) {
            logger.error("Failed to initialise VFS", e);
            e.printStackTrace();
            setActive(false);
            return;
        }

        determineSupportedFileSystems();
        loadLocalFileSystem();
        setActive(true);
    }

    /**
     * Ensures that there is at least a Local FileSystem with the Current
     * directory loaded.
     * 
     * TODO This probably shouldn't be here after we've completed all the VFS
     * preference loading stuff.
     *  
     */
    private void loadLocalFileSystem() {
        if (prefModel.isLoadAllRootsOnStart()) {
            try {

                File[] roots = File.listRoots();
                for (int i = 0; i < roots.length; i++) {
                    File root = roots[i];

                    // Add the authors of the java.io.File class to the list of
                    // people to "have a word" with... This is ridiculous...
                    if (!(root.getAbsolutePath().toLowerCase().startsWith("a:") || root
                            .getAbsolutePath().toLowerCase().startsWith("b:"))) {
                        if (root.exists() && root.canRead()) {
                            FileObject fileObject = this.fileSystemManager
                                    .resolveFile(root.toURL().toExternalForm());
                            DefaultMutableTreeNode node = this.fileSystemTree
                                    .addFileObject("local:"
                                            + root.getAbsolutePath(),
                                            fileObject);
                            USER_MESSAGE_LOGGER.info("Adding "
                                    + root.getAbsolutePath());
                        }
                    }
                }

            } catch (Exception e) {
                logger.error("error creating local VFS", e);
            }
        }
    }

    /**
     * Works out which of the supported File Systems are available.
     */
    private void determineSupportedFileSystems() {
        String[] schemes = fileSystemManager.getSchemes();
        supportedSchemes.addAll(Arrays.asList(schemes));

        logger.info("Supported schemes: " + supportedSchemes);
    }

    /**
     *  
     */
    private void initGUI() {

        setLayout(new BorderLayout());
        rightSplit.add(this.fileObjectTable, JSplitPane.TOP);
        rightSplit.add(this.previewPane, JSplitPane.BOTTOM);
        rightSplit.setResizeWeight(0.75);
        splitPane.add(this.fileSystemTree, JSplitPane.LEFT);
        splitPane.add(rightSplit, JSplitPane.RIGHT);

        add(splitPane, BorderLayout.CENTER);

        fileSystemTree.getTree()
                .addTreeSelectionListener(this.aoTablePopulator);
        fileSystemTree.getTree().addTreeSelectionListener(
                this.aoDirectoryScanner);

        fileObjectTable.getTable().addMouseListener(new MouseAdapter() {

            public void mouseClicked(MouseEvent e) {
                if (e.getClickCount() >= 2) {
                    final FileObject fileObject = (FileObject) fileObjectTable
                            .getFileObject(fileObjectTable.getTable()
                                    .rowAtPoint(e.getPoint()));
                    if (fileObject != null) {
                        Thread thread = new Thread(new AOGeneratePreview(
                                previewPane, fileObject, fileObjectTable));

                        thread.setPriority(Thread.MIN_PRIORITY);
                        thread.start();

                    }
                }
            }
        });
        initMenus();
    }

    /**
     *  
     */
    private void initMenus() {

        JPopupMenu popupMenu = new JPopupMenu();
        popupMenu.add(previewPane.getActions().TOGGLE_PREVIEW_PANEL);
        PopupListener popupListener = new PopupListener(popupMenu);
        rightSplit.addMouseListener(popupListener);
        this.addMouseListener(popupListener);
        previewPane.addMouseListener(popupListener);
        fileObjectTable.getTable().addMouseListener(popupListener);
        //        TODO Work out WTF is going on with this PopupListener not being
        // picked up....
        //        TODO Work out WTF is going on with the split pane and the setVisible
        // like it used to do in LogPanel
    }

    /**
     * Reads in a certain number of lines from the FileObject and sets the
     * Preview pane's preview text from what it reads
     * 
     * @author psmith
     *  
     */
    private final class AOGeneratePreview implements Runnable {

        private final PreviewPanel previewPane;

        private final FileObject fileObject;

        private final FileObjectTable fileObjectTable;

        private AOGeneratePreview(PreviewPanel previewPane,
                FileObject fileObject, FileObjectTable fileObjectTable) {
            super();
            this.previewPane = previewPane;
            this.fileObject = fileObject;
            this.fileObjectTable = fileObjectTable;
        }

        public void run() {
            synchronized (fileObject) {
                try {
                    LineNumberReader reader = new LineNumberReader(
                            new InputStreamReader(
                                    new ProgressMonitorInputStream(
                                            fileObjectTable,
                                            "Generating Preview....",
                                            fileObject.getContent()
                                                    .getInputStream())));

                    StringBuffer buf = new StringBuffer(256);
                    String line;
                    int lineCount = 0;
                    final int MAX = prefModel.getPreviewSize();
                    while (lineCount < MAX
                            && (line = reader.readLine()) != null) {
                        buf.append(line).append("\n");
                        lineCount++;
                    }
                    previewPane.setPreviewText(buf.toString());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

        }
    }

    /**
     * This class will scan a VFSNode for it's children and automatically add
     * them as nodes to the tree
     * 
     * @author psmith
     *  
     */
    private static class AOChildDirectorScanner implements
            TreeSelectionListener {

        private Logger USER_MESSAGE_LOGGER = MessageCenter.getInstance()
                .getLogger();

        /*
         * (non-Javadoc)
         * 
         * @see javax.swing.event.TreeSelectionListener#valueChanged(javax.swing.event.TreeSelectionEvent)
         */
        public void valueChanged(TreeSelectionEvent e) {
            final JTree sourceTree = (JTree) e.getSource();
            final DefaultTreeModel treeModel = (DefaultTreeModel) sourceTree
                    .getModel();

            TreePath path = e.getPath();

            if (path == null) { return; }
            final DefaultMutableTreeNode lastPathComponent = (DefaultMutableTreeNode) path
                    .getLastPathComponent();

            // TODO this method will NEVER remove the children and repopulates
            // if the node already has
            // children, be nice to find out
            // whether VFS can help determine whether it should 'relook' for
            // changes or something.

            if (lastPathComponent == null) {
                return;
            } else if (lastPathComponent.getChildCount() > 0) {
                // already determined Children
                return;
            }

            Object userObject = lastPathComponent.getUserObject();
            if (userObject == null || !(userObject instanceof VFSNode)) { return; }
            final VFSNode vfsNode = (VFSNode) userObject;
            Thread thread = new Thread(new Runnable() {

                public void run() {
                    USER_MESSAGE_LOGGER.info("Scanning directory...");
                    sourceTree.setCursor(Cursor
                            .getPredefinedCursor(Cursor.WAIT_CURSOR));
                    lastPathComponent.removeAllChildren();
                    new BackgroundChildFileObjectPopulator(lastPathComponent,
                            vfsNode).run();
                    treeModel.reload(lastPathComponent);
                    sourceTree.setCursor(Cursor.getDefaultCursor());
                }
            });
            thread.setPriority(Thread.MIN_PRIORITY);
            thread.start();
        }

    }

    /**
     * Triggered when the user selects a node in the tree, it automatically
     * populates all the child node information in the table
     * 
     * @author psmith
     *  
     */
    private static class AOFileTablePopulater implements TreeSelectionListener {

        private DirectoryListTableModel tableModel;

        private Logger USER_MESSAGE_LOGGER = MessageCenter.getInstance()
                .getLogger();

        /**
         * @param tableModel
         */
        public AOFileTablePopulater(DirectoryListTableModel tableModel) {
            this.tableModel = tableModel;
        }

        /*
         * (non-Javadoc)
         * 
         * @see javax.swing.event.TreeSelectionListener#valueChanged(javax.swing.event.TreeSelectionEvent)
         */
        public void valueChanged(TreeSelectionEvent e) {
            Object object = e.getSource();
            TreePath path = e.getNewLeadSelectionPath();
            // if there is no path, then there is nothing selected, so we need
            // to clear the table model... that's it!
            if (path == null) {
                this.tableModel.clear();
                return;
            }
            DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) path
                    .getLastPathComponent();

            Object userObject = treeNode.getUserObject();
            if (!(userObject instanceof VFSNode)) { return; }
            final VFSNode vfsNode = (VFSNode) userObject;

            // IN a background thread, we now populate the children in the
            // tableModel
            Runnable runnable = new Runnable() {

                public void run() {
                    try {
                        FileObject fileObject = vfsNode.getFileObject();
                        FileObject[] fos = null;
                        synchronized (fileObject) {
                            fos = fileObject.getChildren();
                        }
                        Collection objects = new ArrayList(Arrays.asList(fos));
                        for (Iterator iter = objects.iterator(); iter.hasNext();) {
                            FileObject fo = (FileObject) iter.next();
                            synchronized (fo) {
                                if (fo.isReadable()
                                        && fo.getType().hasChildren()) {
                                    iter.remove();
                                }
                            }
                        }
                        tableModel.setFiles(objects);
                    } catch (FileSystemException ex) {
                        USER_MESSAGE_LOGGER.error(
                                "Failed to retrieve children for " + vfsNode,
                                ex);
                        return;
                    }
                }
            };

            Thread thread = new Thread(runnable);
            thread.setPriority(Thread.MIN_PRIORITY);
            thread.start();

        }
    }

    /**
     * Given a tree node, first determine if the user object is a VFSNode, and
     * if not, ignores the request and returns immediately. Otherwise a new,
     * low-priority thread is started to go look for any potential children of
     * the fileObject. As each child is located, an new child TreeNode is added
     * to the passed in node, and done within the Swing's EventDispatchThread.
     * 
     * Child TreeNodes' that are added to this node will have a VFSNode as it's
     * UserObject.
     * 
     * @param node
     */
    private static final class BackgroundChildFileObjectPopulator implements
            Runnable {

        private final VFSNode vfsNode;

        private final DefaultMutableTreeNode node;

        private Logger USER_MESSAGE_LOGGER = MessageCenter.getInstance()
                .getLogger();

        /**
         * @param node
         * @param vfsNode
         */
        public BackgroundChildFileObjectPopulator(DefaultMutableTreeNode node,
                VFSNode vfsNode) {
            this.node = node;
            this.vfsNode = vfsNode;
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Runnable#run()
         */
        public void run() {
            USER_MESSAGE_LOGGER.debug("Looking for children of node "
                    + vfsNode.getName());
            // first, lets add a tempopary node that says "Pending..." in it
            // while we work out what's going on.
            final DefaultMutableTreeNode pendingNode = new DefaultMutableTreeNode(
                    "Pending...");
            SwingUtilities.invokeLater(new Runnable() {

                public void run() {
                    node.add(pendingNode);
                }
            });
            try {
                FileObject fileObject = this.vfsNode.getFileObject();
                List children = null;
                synchronized (fileObject) {
                    children = new ArrayList(Arrays.asList(fileObject
                            .getChildren()));
                }
                Collections.sort(children, VFSUtils.FILE_OBJECT_COMPARATOR);
                USER_MESSAGE_LOGGER.debug("Found " + children.size()
                        + " children");
                for (Iterator iter = children.iterator(); iter.hasNext();) {
                    FileObject child = (FileObject) iter.next();
                    // we only add non-leaf nodes, as the leaf nodes get
                    // displayed in the table
                    synchronized (child) {
                        if (child.getType().hasChildren()) {
                            final DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(
                                    new VFSNode(child.getName().getBaseName(),
                                            child));
                            SwingUtilities.invokeLater(new Runnable() {

                                public void run() {
                                    node.add(childNode);
                                }
                            });
                        }
                    }
                }
            } catch (Exception e) {
                USER_MESSAGE_LOGGER.error("Failed to populate Children", e);
            } finally {
                SwingUtilities.invokeLater(new Runnable() {

                    public void run() {
                        node.remove(pendingNode);
                    }
                });
            }
        }
    }
}