jgroups/tests/GridFilesystemTest.java

package org.jgroups.tests;

import org.jgroups.blocks.GridFile;
import org.jgroups.blocks.GridFilesystem;
import org.jgroups.blocks.ReplCache;
import org.jgroups.util.Util;

import java.io.*;
import java.util.HashMap;
import java.util.Map;

/**
 * @author Bela Ban
 * todo: regexp for file ls, rm, down and up
 * todo: recursive up and down
 */
public class GridFilesystemTest {
    static final Map<String,Command> commands=new HashMap<String,Command>();
    static String current_dir="/";
    static final String HOME=System.getProperty("user.home");

    static {
        commands.put("mkdir", new mkdir());
        commands.put("ls",    new ls());
        commands.put("cd",    new cd());
        commands.put("pwd",   new pwd());
        commands.put("rm",    new rm());
        commands.put("up",    new up());
        commands.put("down",  new down());
    }

    public static void main(String[] args) throws Exception {
        String props="udp.xml";
        String cluster_name="imfs-cluster";
        String metadata_cluster_name="metadata-cluster";
        short default_repl_count=1;
        int default_chunk_size=4000;
        GridFilesystem fs;

        for(int i=0; i < args.length; i++) {
            if(args[i].equals("-props")) {
                props=args[++i];
                continue;
            }
            if(args[i].equals("-cluster_name")) {
                cluster_name=args[++i];
                continue;
            }
            if(args[i].equals("-metadata_cluster_name")) {
                metadata_cluster_name=args[++i];
                continue;
            }
            if(args[i].equals("-repl_count")) {
                default_repl_count=Short.parseShort(args[++i]);
                continue;
            }
            if(args[i].equals("-chunk_size")) {
                default_chunk_size=Integer.parseInt(args[++i]);
                continue;
            }

            System.out.println("GridFilesystemTest [-props <JGroups config>] [-cluster_name <name>] " +
                    "[-metadata_cluster_name <name>] [-repl_count <count>] [-chunk_size <size (bytes)>]");
            return;
        }

        ReplCache<String,byte[]> data=new ReplCache<String,byte[]>(props, cluster_name);
        ReplCache<String, GridFile.Metadata> metadata=new ReplCache<String, GridFile.Metadata>(props, metadata_cluster_name);
        data.start();
        metadata.start();

        fs=new GridFilesystem(data, metadata, default_repl_count, default_chunk_size);
        loop(fs);

        data.stop();
        metadata.stop();
    }

    private static void loop(GridFilesystem fs) {
        while(true) {
            try {
                System.out.print("> ");
                String line=Util.readLine(System.in);
                if(!execute(fs, line))
                    break;
            }
            catch(Throwable t) {
                t.printStackTrace();
            }
        }
    }

    private static boolean execute(GridFilesystem fs, String line) {
        String[] comps=parseCommandLine(line);
        if(comps == null || comps.length == 0) {
            help();
            return true;
        }
        if(comps[0].equalsIgnoreCase("quit") || comps[0].equalsIgnoreCase("exit"))
            return false;
        if(comps[0].equalsIgnoreCase("help")) {
            help();
            return true;
        }
        Command cmd=commands.get(comps[0]);
        if(cmd == null) {
            System.err.println(comps[0] + " not known");
            help();
            return true;
        }
        String[] args=null;
        if(comps.length > 1) {
            args=new String[comps.length -1];
            System.arraycopy(comps, 1, args, 0, args.length);
        }
        cmd.execute(fs, args);
        return true;
    }

    private static void help() {
        StringBuilder sb=new StringBuilder("Valid commands:\nhelp\nquit\nexit\n");
        for(Command cmd: commands.values()) {
            String help=cmd.help();
            if(help != null)
                sb.append(help).append("\n");
        }
        System.out.println(sb.toString());
    }

    private static String[] parseCommandLine(String line) {
        if(line == null)
            return null;
        return line.trim().split(" ");
    }


    private static interface Command {
        void execute(GridFilesystem fs, String[] args);
        String help();
    }

    private static class ls implements Command {

        public void execute(GridFilesystem fs, String[] args) {
            String options=parseOptions(args);
            boolean recursive=options.contains("R");
            boolean detailed=options.contains("l");
            String[] files=getNonOptions(args);
            if(files == null || files.length == 0)
                files=new String[]{current_dir};
            for(String str: files) {
                if(!str.startsWith(File.separator))
                    str=current_dir + File.separator + str;
                File file=fs.getFile(str);
                if(!file.exists()) {
                    System.err.println("File " + file + " doesn't exist");
                    continue;
                }
                print(file, detailed, recursive, 0, file.isDirectory());
            }
        }

        public String help() {
            return "ls [-lR] [dirs | files]";
        }
    }

    private static class mkdir implements Command {

        public void execute(GridFilesystem fs, String[] args) {
            String options=parseOptions(args);
            boolean recursive=options.contains("p");
            String[] dir_names=getNonOptions(args);
            if(dir_names == null || dir_names.length < 1) {
                System.err.println(help());
                return;
            }
            for(String dir: dir_names) {
                if(!dir.startsWith(File.separator))
                    dir=current_dir + File.separator + dir;
                File file=fs.getFile(dir);
                boolean result;
                if(recursive)
                    result=file.mkdirs();
                else
                    result=file.mkdir();
                if(!result)
                    System.err.println("failed creating " + dir);
            }
        }

        public String help() {
            return "mkdir [-p] dirs";
        }
    }


    private static class rm implements Command {

        public void execute(GridFilesystem fs, String[] args) {
            String options=parseOptions(args);
            boolean recursive=options.contains("r");
            String[] dir_names=getNonOptions(args);
            if(dir_names == null || dir_names.length < 1) {
                System.err.println(help());
                return;
            }
            for(String dir: dir_names) {
                if(!dir.startsWith(File.separator))
                    dir=current_dir.equals(File.separator)? current_dir + dir : current_dir + File.separator + dir;
                File file=fs.getFile(dir);
                if(!file.exists()) {
                    System.err.println(file.getName() + " doesn't exist");
                    return;
                }
                if(file.isFile()) {
                    if(!file.delete())
                        System.err.println("cannot remove " + file.getName());
                    return;
                }

                if(!recursive) {
                    if(!file.delete())
                        System.err.println("cannot remove " + file.getName() + ": is a directory");
                }
                else {
                    if(!delete(file)) { // recursive delete
                        System.err.println("recursive removal of " + file.getName() + " failed");
                    }
                }
            }
        }

        public String help() {
            return "rm [-fr] <files or dirs>";
        }
    }


    private static class cd implements Command {

        public void execute(GridFilesystem fs, String[] args) {
            String[] tmp=getNonOptions(args);
            String target_dir="~";
            if(tmp != null && tmp.length == 1)
                target_dir=tmp[0];

            if(target_dir.equals(".."))
                target_dir=new File(current_dir).getParent();
            if(target_dir.contains("~") && HOME != null)
                target_dir=target_dir.replace("~", HOME);
            if(!target_dir.trim().startsWith(File.separator)) {
                target_dir=current_dir.equals(File.separator)?
                        current_dir + target_dir :
                        current_dir + File.separator + target_dir;
            }
            File dir=fs.getFile(target_dir);
            if(!dir.exists()) {
                System.err.println("Directory " + target_dir + " doesn't exist");
            }
            else
                current_dir=target_dir;
        }

        public String help() {
            return "cd [dir]";
        }
    }

    private static class pwd implements Command {

        public void execute(GridFilesystem fs, String[] args) {
            System.out.println(current_dir);
        }

        public String help() {
            return "pwd";
        }
    }


    private static class up implements Command {

        public void execute(GridFilesystem fs, String[] args) {
            String   options=parseOptions(args);
            String[] real_args=getNonOptions(args);
            boolean  overwrite=options.contains("f");

            if(real_args.length == 0) {
                System.err.println(help());
                return;
            }

            String local_path=real_args[0], grid_path=real_args.length > 1? real_args[1] : null;
            if(HOME != null && local_path.contains("~"))
                local_path=local_path.replace("~", HOME);
            String target_path=grid_path != null? grid_path : local_path;
            if(target_path.contains("~"))
                target_path=target_path.replace("~", HOME);
            if(target_path.equals("."))
                target_path=current_dir;

            File target=fs.getFile(target_path);
            if(!overwrite && target.exists() && target.isFile()) {
                System.err.println("grid file " + target_path + " already exists; use -f to force overwrite");
                return;
            }

            if(target.exists() && target.isDirectory()) {
                String[] comps=Util.components(local_path, File.separator);
                String filename=comps[comps.length - 1];
                target_path=target_path + (target_path.equals(File.separator)? filename : File.separator + filename);
            }

            FileInputStream in=null;
            OutputStream out=null;
            try {
                in=new FileInputStream(local_path);
                File out_file=fs.getFile(target_path);
                if(out_file.exists() && out_file.isDirectory()) {
                    System.err.println("target " + target_path + " is a directory");
                    return;
                }
                if(out_file.exists() && out_file.isFile() && overwrite) {
                    if(out_file instanceof GridFile)
                        ((GridFile)out_file).delete(true);
                    else
                        out_file.delete();
                }

                out=fs.getOutput((GridFile)out_file);
                byte[] buf=new byte[50000];
                int len, total=0;
                while((len=in.read(buf, 0, buf.length)) != -1) {
                    out.write(buf, 0, len);
                    total+=len;
                }
                System.out.println("uploaded " + local_path + " to " + target_path + " (" + total + " bytes)");
            }
            catch(FileNotFoundException e) {
                System.err.println("local file " + local_path + " not found");
            }
            catch(IOException e) {
                System.err.println("cannot create " + target_path);
            }
            finally {
                Util.close(in);
                Util.close(out);
            }
        }

        public String help() {
            return "up [-f] <local path> [<grid path>]";
        }
    }


    private static class down implements Command {

        public void execute(GridFilesystem fs, String[] args) {
            String   options=parseOptions(args);
            String[] real_args=getNonOptions(args);
            boolean  overwrite=options.contains("f");

            if(real_args.length == 0) {
                System.err.println(help());
                return;
            }

            String grid_path=real_args[0], local_path=real_args.length > 1? real_args[1] : null;
            if(HOME != null && grid_path.contains("~"))
                grid_path=grid_path.replace("~", HOME);
            String target_path=local_path != null? local_path : grid_path;
            if(target_path.contains("~"))
                target_path=target_path.replace("~", HOME);
            if(target_path.equals("."))
                target_path=System.getProperty("user.dir");

            File target=new File(target_path);
            if(!overwrite && target.exists() && target.isFile()) {
                System.err.println("grid file " + target_path + " already exists; use -f to force overwrite");
                return;
            }

            if(target.exists() && target.isDirectory()) {
                String[] comps=Util.components(grid_path, File.separator);
                String filename=comps[comps.length - 1];
                target_path=target_path + (target_path.endsWith(File.separator)? filename : File.separator + filename);
            }

            InputStream in=null;
            FileOutputStream out=null;
            try {
                in=fs.getInput(grid_path);
                File out_file=new File(target_path);
                if(out_file.exists() && out_file.isDirectory()) {
                    System.err.println("target " + target_path + " is a directory");
                    return;
                }
                out=new FileOutputStream(out_file);
                byte[] buf=new byte[50000];
                int len, total=0;
                while((len=in.read(buf, 0, buf.length)) != -1) {
                    out.write(buf, 0, len);
                    total+=len;
                }
                System.out.println("downloaded " + local_path + " to " + target_path + " (" + total + " bytes)");
            }
            catch(FileNotFoundException e) {
                System.err.println("local file " + local_path + " not found");
            }
            catch(IOException e) {
                System.err.println("cannot create " + target_path);
            }
            finally {
                Util.close(in);
                Util.close(out);
            }
        }

        public String help() {
            return "down [-f] <grid path> [<local path>]";
        }
    }


    private static String parseOptions(String[] args) {
        StringBuilder sb=new StringBuilder();
        if(args == null)
            return "";
        for(String str: args) {
            if(str.startsWith("-"))
                sb.append(str.substring(1));
        }
        return sb.toString();
    }

    private static String[] getNonOptions(String[] args) {
        if(args == null)
            return null;
        int cnt=0;
        for(String str: args)
            if(!str.startsWith("-"))
                cnt++;
        String[] retval=new String[cnt];
        cnt=0;
        for(String str: args)
            if(!str.startsWith("-"))
                retval[cnt++]=str;
        return retval;
    }

    private static boolean delete(File dir) {
        boolean retval=true;
        if(dir == null)
            return false;
        File[] files=dir.listFiles();
        if(files != null) {
            for(File file: files) {
                if(!delete(file))
                    retval=false;
            }
        }
        boolean rc=dir instanceof GridFile? ((GridFile)dir).delete(true) : dir.delete();
        if(!rc)
            retval=false;
        return retval;
    }

    private static void print(File file, boolean details, boolean recursive, int indent, boolean exclude_self) {
        if(file.isDirectory()) {
            if(!exclude_self)
                System.out.print(print(file, details, indent));
            File[] children=file.listFiles();
            for(File child: children) {
                if(!recursive)
                    System.out.print(print(child, details, indent));
                else {
                    print(child, details, recursive, indent +4, false);
                }
            }
            if(children.length > 0)
                System.out.println("");
        }
        else {
            String tmp=print(file, details, indent);
            System.out.print(tmp);
        }
    }

    private static String print(File file, boolean details, int indent) {
        StringBuilder sb=new StringBuilder();
        if(file.isDirectory()) {
            if(details)
                sb.append(indent(indent));
            sb.append(file.getName()).append("/");
        }
        else {
            if(details)
                sb.append(indent(indent));
            sb.append(file.getName());
            if(details) {
                sb.append(" " + Util.printBytes(file.length()));
                if(file instanceof GridFile)
                    sb.append(", chunk_sise=" + ((GridFile)file).getChunkSize());
            }

        }
        sb.append(details? '\n' : ' ');
        return sb.toString();
    }

    private static String indent(int num) {
        StringBuilder sb=new StringBuilder();
        for(int i=0; i < num; i++)
            sb.append(' ');
        return sb.toString();
    }


}