Examples with OptionParser joptsimple.OptionParser used on opensource projects

Example 1 with OptionParser

use of joptsimple.OptionParser in project cogtool by cogtool.

the class CogTool method main.

public static void main(String[] args) {
    // Do a clean exit if running on a machine with an old JRE.
    if (!OSUtils.supportCogTool()) {
        System.out.println("JRE 1.5 or later is required to run CogTool");
        // TODO: add simple window with message?
        System.exit(1024);
    }
    if (revision == null) {
        // we're running under the development environment; get the revision
        // dynamically, and also make our subprocesses echo what's going
        // on to stdout
        revision = getRevisionAtRuntime();
        Subprocess.setDebug(true);
    }
    // Insert the two phases into the delayed work manager, selection
    // first and repaint second, since selection can cause repaint requests
    delayedWorkMgr.addDelayedWork(selectionPhase);
    delayedWorkMgr.addDelayedWork(repaintPhase);
    try {
        if (OSUtils.MACOSX) {
            if (!OSUtils.isIntelMac()) {
                System.out.println("CogTool no longer runs on PowerPC");
                System.exit(16);
            }
            // we need to create the RootController, but will never
            // actually need to interact with it programmatically
            rootCtl = new RootController();
        }
        // TODO temporary kludge until we update the preference dialog to supply
        //      a UI for turning this on and off
        CogToolPref.IS_LOGGING.setBoolean(true);
        enableLogging(CogToolPref.IS_LOGGING.getBoolean());
        OptionParser parser = new OptionParser("f:i:re:s:qQ");
        // The psn is supplied on MacOS when a GUI application is double-clicked;
        // we just ignore it, but need to recognize it so we can ignore it.
        parser.accepts("psn", "process serial number (ignored)").withRequiredArg();
        OptionSet opts = parser.parse(args);
        if (opts.has("Q")) {
            quietCommands = true;
        }
        List<String> filesToLoad = new ArrayList<String>();
        for (Object obj : opts.nonOptionArguments()) {
            filesToLoad.add((String) obj);
        }
        List<RecoverableException> loadExceptions = new ArrayList<RecoverableException>();
        ProjectController openedProject = null;
        File file = null;
        if (!filesToLoad.isEmpty()) {
            ObjectPersister persister = ObjectPersister.ONLY;
            for (String fn : filesToLoad) {
                try {
                    file = new File(fn);
                    Project proj = (Project) persister.load(file);
                    openedProject = ProjectController.openController(proj, false, true);
                } catch (Exception e) {
                    RecoverableException re = new RecoverableException("Error occurred while loading: " + fn, e);
                    RcvrExceptionHandler.recover(re, interaction);
                }
            }
        }
        if (opts.has("f")) {
            openedProject = (new CommandFile((String) opts.valueOf("f"))).run();
        } else {
            if (opts.has("i")) {
                openedProject = ProjectController.newProjectController();
                openedProject.importFile = new File((String) opts.valueOf("i"));
                openedProject.importFileComputes = opts.has("r");
                openedProject.performAction(CogToolLID.ImportXML, new ProjectContextSelectionState(openedProject.getModel()));
            }
            if (openedProject != null && opts.has("e")) {
                openedProject.exportFile = (String) opts.valueOf("e");
                openedProject.exportResultsToCSV();
            }
            if (openedProject != null && opts.has("s")) {
                openedProject.saveAsFilename((String) opts.valueOf("s"));
            }
            if (opts.has("q")) {
                System.exit(0);
            }
        }
        if (openedProject != null) {
            if (System.getProperty("edu.cmu.cs.hcii.cogtool.ExportCSVKludge") != null) {
                exportCSVKludgeDir = file.getAbsoluteFile().getParentFile();
                openedProject.exportCSVKludge();
                System.exit(0);
            }
        }
        if (openedProject == null) {
            // no project was opened successfully, or none were specified,
            // so create a fresh project and use its Interaction to
            // report load errors
            ProjectController c = ProjectController.newProjectController();
            c.setLocation(25.0, 25.0);
            String response = c.getInteraction().createNewOrOpenExisting();
            if (response == ProjectInteraction.CREATE) {
                // Populate the empty project to avoid a "blank screen".
                c.populateProject();
            } else if (response == null) {
                c.requestClose();
            } else {
                if (response == ProjectInteraction.OPEN) {
                    c.openExistingProject(c.getLocation());
                } else {
                    c.performAction(CogToolLID.OpenProjectFile, response, false);
                }
                if (ControllerRegistry.ONLY.openControllerCount() > 1) {
                    c.requestClose();
                }
            }
        }
        //            } else if (command.equals("export-csv")) {
        //                if (openedProject == null) {
        //                    System.err.println(String.format(
        //                            L10N.get("CT.NoFileForCSV",
        //                                     "Couldn't open %s for CSV export."),
        //                            arguments.get(0)));
        //                    System.exit(32);
        //                }
        //                exportCSVKludgeDir =
        //                    file.getAbsoluteFile().getParentFile();
        //                openedProject.exportCSVKludge();
        //                System.exit(0);
        //            }
        // Note that the following catches and does not rethrow any
        // SWTExceptions. This means reportTopLevelException never gets
        // a chance to report these to the user.
        WindowUtil.interact();
    } catch (RecoverableException e) {
        RcvrExceptionHandler.recover(e, interaction);
    } catch (Exception e) {
        System.err.println("Catching exception...");
        reportTopLevelAnomaly(e);
    } catch (Error e) {
        // Before trying to throw up a dialog it is important that we dump
        // the trace to stderr, the same way as would happen if this went
        // uncaught. At least that way if we are in so hosed a state that
        // we can't even popup the dialog we've made the patient no worse
        // than it would have been had we not caught this. We don't even
        // wait for reportTopLevelAnomoly before printing it in case just
        // that extra level of function call will make a difference in
        // whether or not we succeed.
        System.err.println("Catching error...");
        e.printStackTrace();
        reportTopLevelAnomaly(e);
    } catch (Throwable e) {
        // This shouldn't be possible -- the only unchecked Throwables
        // are Errors and RuntimeExceptions, both of which should have
        // been caught above. But just in case someone does something
        // deeply bizarre and has something we call in this try able to
        // throw a checked non-Exception Throwable, let's be extra paranoid.
        System.err.println("Catching throwable...");
        reportTopLevelAnomaly(new Exception(L10N.get("CT.UncaughtThrowable", ("Uncaught non-Exception, non-Error Throwable " + "propagated all the way to top-level.")), e));
    }
    // here.
    if (!WindowUtil.GLOBAL_DISPLAY.isDisposed()) {
        WindowUtil.GLOBAL_DISPLAY.close();
    }
    // Just calling the preceding is *not* sufficient to ensure we quit,
    // in the rare case where we've thrown a non-recoverable Exception
    // but left a background thread alive
    System.exit(-1);
}

Example 2 with OptionParser

use of joptsimple.OptionParser in project jackrabbit-oak by apache.

the class DataStoreCacheUpgradeCommand method execute.

@Override
public void execute(String... args) throws Exception {
    OptionParser parser = new OptionParser();
    try {
        OptionSpec<File> homeDirOption = parser.accepts("homeDir", "Home directory of the datastore where the pending uploads is serialized").withRequiredArg().ofType(File.class).required();
        OptionSpec<File> pathOption = parser.accepts("path", "Parent directory of the datastore").withRequiredArg().ofType(File.class).required();
        OptionSpec<Boolean> moveCacheOption = parser.accepts("moveCache", "Move DataStore download cache").withOptionalArg().ofType(Boolean.class).defaultsTo(true);
        OptionSpec<Boolean> delPendingUploadsMapFileOption = parser.accepts("deleteMapFile", "Delete pending uploads file post upgrade").withOptionalArg().ofType(Boolean.class).defaultsTo(true);
        OptionSpec<?> help = parser.acceptsAll(asList("h", "?", "help"), "show help").forHelp();
        OptionSet options = null;
        try {
            options = parser.parse(args);
        } catch (Exception e) {
            System.err.println(e);
            parser.printHelpOn(System.err);
            return;
        }
        if (options.has(help)) {
            parser.printHelpOn(System.out);
            return;
        }
        File homeDir = options.valueOf(homeDirOption);
        File path = options.valueOf(pathOption);
        boolean moveCache = options.valueOf(moveCacheOption);
        boolean delPendingUploadsMapFile = options.valueOf(delPendingUploadsMapFileOption);
        System.out.println("homeDir " + homeDir);
        System.out.println("path " + path);
        System.out.println("moveCache " + moveCache);
        System.out.println("delPendingUploadsMapFile " + delPendingUploadsMapFile);
        DataStoreCacheUpgradeUtils.upgrade(homeDir, path, moveCache, delPendingUploadsMapFile);
    } catch (Exception e) {
        e.printStackTrace();
        System.err.println("Error upgrading cache");
    }
}

Example 3 with OptionParser

use of joptsimple.OptionParser in project jackrabbit-oak by apache.

the class DataStoreCheckCommand method execute.

@Override
public void execute(String... args) throws Exception {
    OptionParser parser = new OptionParser();
    parser.allowsUnrecognizedOptions();
    String helpStr = "datastorecheck [--id] [--ref] [--consistency] [--store <path>|<mongo_uri>] " + "[--s3ds <s3ds_config>|--fds <fds_config>|--azureblobds <azureblobds_config>] [--dump <path>]";
    Closer closer = Closer.create();
    try {
        // Options for operations requested
        OptionSpecBuilder idOp = parser.accepts("id", "Get ids");
        OptionSpecBuilder refOp = parser.accepts("ref", "Get references");
        OptionSpecBuilder consistencyOp = parser.accepts("consistency", "Check consistency");
        // Node Store - needed for --ref, --consistency
        ArgumentAcceptingOptionSpec<String> store = parser.accepts("store", "Node Store").requiredIf(refOp, consistencyOp).withRequiredArg().ofType(String.class);
        // Optional argument to specify the dump path
        ArgumentAcceptingOptionSpec<String> dump = parser.accepts("dump", "Dump Path").withRequiredArg().ofType(String.class);
        // Optional argument to specify tracking
        ArgumentAcceptingOptionSpec<String> track = parser.accepts("track", "Local repository home folder").withRequiredArg().ofType(String.class);
        OptionSpec<?> help = parser.acceptsAll(asList("h", "?", "help"), "show help").forHelp();
        // Required rules (any one of --id, --ref, --consistency)
        idOp.requiredUnless(refOp, consistencyOp);
        refOp.requiredUnless(idOp, consistencyOp);
        consistencyOp.requiredUnless(idOp, refOp);
        OptionSet options = null;
        try {
            options = parser.parse(args);
        } catch (Exception e) {
            System.err.println(e);
            parser.printHelpOn(System.err);
            return;
        }
        if (options.has(help)) {
            parser.printHelpOn(System.out);
            return;
        }
        String dumpPath = JAVA_IO_TMPDIR.value();
        if (options.has(dump)) {
            dumpPath = options.valueOf(dump);
        }
        GarbageCollectableBlobStore blobStore = null;
        BlobReferenceRetriever marker = null;
        if (options.has(store)) {
            String source = options.valueOf(store);
            if (source.startsWith(MongoURI.MONGODB_PREFIX)) {
                MongoClientURI uri = new MongoClientURI(source);
                MongoClient client = new MongoClient(uri);
                DocumentNodeStore nodeStore = new DocumentMK.Builder().setMongoDB(client.getDB(uri.getDatabase())).getNodeStore();
                closer.register(Utils.asCloseable(nodeStore));
                blobStore = (GarbageCollectableBlobStore) nodeStore.getBlobStore();
                marker = new DocumentBlobReferenceRetriever(nodeStore);
            } else {
                marker = SegmentTarUtils.newBlobReferenceRetriever(source, closer);
            }
        }
        // Initialize S3/FileDataStore if configured
        GarbageCollectableBlobStore dataStore = Utils.bootstrapDataStore(args, closer);
        if (dataStore != null) {
            blobStore = dataStore;
        }
        // blob store still not initialized means configuration not supported
        if (blobStore == null) {
            System.err.println("Operation not defined for SegmentNodeStore without external datastore");
            parser.printHelpOn(System.err);
            return;
        }
        FileRegister register = new FileRegister(options);
        closer.register(register);
        if (options.has(idOp) || options.has(consistencyOp)) {
            File dumpFile = register.createFile(idOp, dumpPath);
            retrieveBlobIds(blobStore, dumpFile);
            // If track path specified copy the file to the location
            if (options.has(track)) {
                String trackPath = options.valueOf(track);
                File trackingFileParent = new File(FilenameUtils.concat(trackPath, "blobids"));
                File trackingFile = new File(trackingFileParent, "blob-" + String.valueOf(System.currentTimeMillis()) + ".gen");
                FileUtils.copyFile(dumpFile, trackingFile);
            }
        }
        if (options.has(refOp) || options.has(consistencyOp)) {
            retrieveBlobReferences(blobStore, marker, register.createFile(refOp, dumpPath));
        }
        if (options.has(consistencyOp)) {
            checkConsistency(register.get(idOp), register.get(refOp), register.createFile(consistencyOp, dumpPath));
        }
    } catch (Throwable t) {
        t.printStackTrace();
    } finally {
        closer.close();
    }
}

Example 4 with OptionParser

use of joptsimple.OptionParser in project jackrabbit-oak by apache.

the class GraphCommand method execute.

@Override
public void execute(String... args) throws Exception {
    OptionParser parser = new OptionParser();
    OptionSpec<File> directoryArg = parser.nonOptions("Path to segment store (required)").ofType(File.class);
    OptionSpec<File> outFileArg = parser.accepts("output", "Output file").withRequiredArg().ofType(File.class).defaultsTo(new File("segments.gdf"));
    OptionSpec<Long> epochArg = parser.accepts("epoch", "Epoch of the segment time stamps (derived from journal.log if not given)").withRequiredArg().ofType(Long.class);
    OptionSpec<Void> gcGraphArg = parser.accepts("gc", "Write the gc generation graph instead of the full graph");
    OptionSpec<String> regExpArg = parser.accepts("pattern", "Regular exception specifying which nodes to include (optional). " + "Ignore when --gc is specified.").withRequiredArg().ofType(String.class);
    OptionSet options = parser.parse(args);
    File directory = directoryArg.value(options);
    if (directory == null) {
        System.err.println("Dump the segment graph to a file. Usage: graph [File] <options>");
        parser.printHelpOn(System.err);
        System.exit(-1);
    }
    String regExp = regExpArg.value(options);
    File outFile = outFileArg.value(options);
    Date epoch;
    if (options.has(epochArg)) {
        epoch = new Date(epochArg.value(options));
    } else {
        Calendar c = Calendar.getInstance();
        c.setTimeInMillis(new File(directory, "journal.log").lastModified());
        c.set(Calendar.HOUR_OF_DAY, 0);
        c.set(Calendar.MINUTE, 0);
        c.set(Calendar.SECOND, 0);
        c.set(Calendar.MILLISECOND, 0);
        epoch = c.getTime();
    }
    if (outFile.exists()) {
        outFile.delete();
    }
    System.out.println("Setting epoch to " + epoch);
    System.out.println("Writing graph to " + outFile.getAbsolutePath());
    FileOutputStream out = new FileOutputStream(outFile);
    boolean gcGraph = options.has(gcGraphArg);
    SegmentTarUtils.graph(directory, gcGraph, epoch, regExp, out);
}

Example 5 with OptionParser

use of joptsimple.OptionParser in project jackrabbit-oak by apache.

the class PersistentCacheCommand method execute.

@SuppressWarnings("unchecked")
@Override
public void execute(String... args) throws Exception {
    OptionParser parser = new OptionParser();
    OptionSpec<String> pathSpec = parser.accepts("path", "only list entries starting with this path prefix").withOptionalArg().defaultsTo("/");
    OptionSpec<String> revisionSpec = parser.accepts("revision", "only list revisions that start with this prefix").withRequiredArg().defaultsTo("");
    OptionSpec<String> mapSpec = parser.accepts("map", "only print contents of this map").withRequiredArg().defaultsTo("");
    OptionSpec<Void> valuesSpec = parser.accepts("values", "print values, not just keys and value lengths");
    OptionSpec<Void> rawSpec = parser.accepts("raw", "print raw data (tab separated map name, key, length, value)");
    OptionSpec<String> outSpec = parser.accepts("out", "print to this file instead of stdout").withRequiredArg().defaultsTo("");
    OptionSpec<?> helpSpec = parser.acceptsAll(asList("h", "?", "help"), "show help").forHelp();
    OptionSet options = parser.parse(args);
    parser.nonOptions("persistent cache file (required)").ofType(File.class);
    if (options.has(helpSpec) || options.nonOptionArguments().isEmpty()) {
        System.out.println("Mode: " + PERSISTENTCACHE);
        System.out.println("Map names and statistic are listed if just the file name is specified.");
        System.out.println("To list all keys, just specify '/' and the file name.");
        System.out.println("To dump multiples files in one go, add multiple file names.");
        System.out.println("Files are accessed in read-only mode; " + "to analyze a running system you need to copy the cache file first.");
        System.out.println("Output format is CSV (',' replaced with '#')");
        System.out.println("To import in H2, use: " + "create table cache as select * from csvread('cache.csv', null, 'fieldDelimiter=')");
        System.out.println();
        parser.printHelpOn(System.out);
        return;
    }
    String path = pathSpec.value(options);
    String revision = revisionSpec.value(options);
    String map = mapSpec.value(options);
    boolean values = options.has(valuesSpec);
    boolean raw = options.has(rawSpec);
    String out = outSpec.value(options);
    PrintWriter write = new PrintWriter(System.out);
    if (out.length() > 0) {
        write = new PrintWriter(new BufferedWriter(new FileWriter(out)));
    }
    for (String fileName : ((List<String>) options.nonOptionArguments())) {
        dump(write, path, revision, map, fileName, values, raw);
    }
    write.flush();
}