public static void main( String[] args ) throws Exception { Args arg = Args.withFlags( HEAP ).parse( args == null ? new String[0] : args ); boolean doHeapDump = arg.getBoolean( HEAP, false, true ); String[] containing = arg.orphans().toArray( new String[arg.orphans().size()] ); String dumpDir = arg.get( DIR, "data" ); new DumpProcessInformation( FormattedLogProvider.toOutputStream( System.out ), new File( dumpDir ) ).dumpRunningProcesses( doHeapDump, containing ); }
@Test void testInterleavedParametersWithValuesAndNot() { String[] line = { "-host", "machine.foo.com", "-port", "1234", "-v", "-name", "othershell" }; Args args = Args.parse( line ); assertEquals( "machine.foo.com", args.get( "host", null ) ); assertEquals( "1234", args.get( "port", null ) ); assertEquals( 1234, args.getNumber( "port", null ).intValue() ); assertEquals( "othershell", args.get( "name", null ) ); assertTrue( args.has( "v" ) ); assertTrue( args.orphans().isEmpty() ); }
@Deprecated @SafeVarargs public final <T> T interpretOption( String key, Function<String,T> defaultValue, Function<String,T> converter, Validator<T>... validators ) { T value; if ( !has( key ) ) { value = defaultValue.apply( key ); } else { String stringValue = get( key ); value = converter.apply( stringValue ); } return validated( value, validators ); }
public static Args useArgumentsFromFileArgumentIfPresent( Args args ) throws IOException { String fileArgument = args.get( Options.FILE.key(), null ); if ( fileArgument != null ) { // Are there any other arguments supplied, in addition to this -f argument? if ( args.asMap().size() > 1 ) { throw new IllegalArgumentException( "Supplying arguments in addition to " + Options.FILE.argument() + " isn't supported." ); } // Read the arguments from the -f file and use those instead args = Args.parse( parseFileArgumentList( new File( fileArgument ) ) ); } return args; }
Args args = Args.parse( incomingArguments ); storeDir = args.interpretOption( Options.STORE_DIR.key(), Converters.mandatory(), Converters.toFile(), Validators.DIRECTORY_IS_WRITABLE ); Config config = Config.defaults( GraphDatabaseSettings.neo4j_home, storeDir.getAbsolutePath() ); skipBadEntriesLogging = args.getBoolean( Options.SKIP_BAD_ENTRIES_LOGGING.key(), (Boolean) Options.SKIP_BAD_ENTRIES_LOGGING.defaultValue(), false); if ( !skipBadEntriesLogging ) String maxMemoryString = args.get( Options.MAX_MEMORY.key(), null ); maxMemory = parseMaxMemory( maxMemoryString ); enableStacktrace = args.getBoolean( Options.STACKTRACE.key(), Boolean.FALSE, Boolean.TRUE ); processors = args.getNumber( Options.PROCESSORS.key(), null ); idType = args.interpretOption( Options.ID_TYPE.key(), withDefault( (IdType)Options.ID_TYPE.defaultValue() ), TO_ID_TYPE ); badTolerance = parseNumberOrUnlimited( args, Options.BAD_TOLERANCE ); inputEncoding = Charset.forName( args.get( Options.INPUT_ENCODING.key(), defaultCharset().name() ) ); skipBadRelationships = args.getBoolean( Options.SKIP_BAD_RELATIONSHIPS.key(), (Boolean)Options.SKIP_BAD_RELATIONSHIPS.defaultValue(), true ); skipDuplicateNodes = args.getBoolean( Options.SKIP_DUPLICATE_NODES.key(), (Boolean)Options.SKIP_DUPLICATE_NODES.defaultValue(), true ); ignoreExtraColumns = args.getBoolean( Options.IGNORE_EXTRA_COLUMNS.key(), (Boolean)Options.IGNORE_EXTRA_COLUMNS.defaultValue(), true ); defaultHighIO = args.getBoolean( Options.HIGH_IO.key(), (Boolean)Options.HIGH_IO.defaultValue(), true );
@Test void shouldStillAllowExplicitValuesForFlags() { // Given Args args = Args.withFlags( "foo", "bar" ).parse("-foo=false", "--bar"); // When List<String> orphans = args.orphans(); // Then assertEquals( Arrays.<String>asList() , orphans ); assertFalse( args.getBoolean( "foo", false, false ) ); assertTrue( args.getBoolean( "bar", false, true ) ); }
public boolean version() { return args.getBoolean( VERSION_ARG, false ); } }
void start( String[] arguments, CtrlCHandler signalHandler ) Args args = Args.withFlags( ARG_READONLY ).parse( arguments ); if ( args.has( "?" ) || args.has( "h" ) || args.has( "help" ) || args.has( "usage" ) ) String path = args.get( ARG_PATH, null ); String host = args.get( ARG_HOST, null ); String port = args.get( ARG_PORT, null ); String name = args.get( ARG_NAME, null ); String pid = args.get( ARG_PID, null ); boolean version = args.getBoolean( ARG_VERSION, false, true ); String readonly = args.get( ARG_READONLY, null ); if ( readonly != null )
CsvImporter( Args args, Config databaseConfig, OutsideWorld outsideWorld ) throws IncorrectUsage { this.args = args; this.outsideWorld = outsideWorld; nodesFiles = extractInputFiles( args, "nodes", outsideWorld.errorStream() ); relationshipsFiles = extractInputFiles( args, "relationships", outsideWorld.errorStream() ); reportFileName = args.interpretOption( "report-file", withDefault( ImportCommand.DEFAULT_REPORT_FILE_NAME ), s -> s ); ignoreExtraColumns = args.getBoolean( "ignore-extra-columns", false ); ignoreDuplicateNodes = args.getBoolean( "ignore-duplicate-nodes", false ); ignoreBadRelationships = args.getBoolean( "ignore-missing-nodes", false ); try { validateInputFiles( nodesFiles, relationshipsFiles ); } catch ( IllegalArgumentException e ) { throw new IncorrectUsage( e.getMessage() ); } idType = args.interpretOption( "id-type", withDefault( IdType.STRING ), from -> IdType.valueOf( from.toUpperCase() ) ); inputEncoding = Charset.forName( args.get( "input-encoding", defaultCharset().name() ) ); highIO = args.getBoolean( "high-io", null, true ); // intentionally left as null if not specified this.databaseConfig = databaseConfig; }
private static ConsistencyCheck parseConsistencyChecker( Args args ) { boolean verify = args.getBoolean( VERIFY, true, true ); if ( verify ) { String consistencyCheckerName = args.get( CONSISTENCY_CHECKER, ConsistencyCheck.FULL.name(), ConsistencyCheck.FULL.name() ); return ConsistencyCheck.fromString( consistencyCheckerName ); } return ConsistencyCheck.NONE; }
@Test void testBooleanWithDefault() { // Given Args args = Args.parse( "--no_value" ); // When & then assertThat( args.getBoolean( "not_set", true, true ), equalTo( true ) ); assertThat( args.getBoolean( "not_set", false, true ), equalTo( false ) ); assertThat( args.getBoolean( "not_set", false, false ), equalTo( false ) ); assertThat( args.getBoolean( "not_set", true, false ), equalTo( true ) ); assertThat( args.getBoolean( "no_value", true, true ), equalTo( true ) ); assertThat( args.getBoolean( "no_value", false, true ), equalTo( true ) ); assertThat( args.getBoolean( "no_value", false, false ), equalTo( false ) ); assertThat( args.getBoolean( "no_value", true, false ), equalTo( false ) ); }
private BackupOutcome runBackup( Args args ) throws ToolFailureException { String host = args.get( HOST ).trim(); int port = args.getNumber( PORT, BackupServer.DEFAULT_PORT ).intValue(); Path to = Paths.get( args.get( TO ).trim() ); Config tuningConfiguration = readConfiguration( args ); boolean forensics = args.getBoolean( FORENSICS, false, true ); ConsistencyCheck consistencyCheck = parseConsistencyChecker( args ); if ( host.contains( ":" ) ) { if ( !host.startsWith( "[" ) ) { host = "[" + host; } if ( !host.endsWith( "]" ) ) { host += "]"; } } long timeout = args.getDuration( TIMEOUT, BackupClient.BIG_READ_TIMEOUT ); URI backupURI = newURI( DEFAULT_SCHEME + "://" + host + ":" + port ); // a bit of validation HostnamePort hostnamePort = newHostnamePort( backupURI ); return executeBackup( hostnamePort, to, consistencyCheck, tuningConfiguration, timeout, forensics ); }
@Test void parsesValues1() { OptionalBooleanArg arg = new OptionalBooleanArg( "foo", false, "" ); assertEquals( "false", arg.parse( Args.parse() ) ); assertEquals( "false", arg.parse( Args.parse( "--foo=false" ) ) ); assertEquals( "true", arg.parse( Args.parse( "--foo=true" ) ) ); assertEquals( "true", arg.parse( Args.parse( "--foo" ) ) ); }
@Test void shouldInterpretMultipleOptionValues() { // GIVEN Collection<Integer> expectedValues = Arrays.asList( 12, 34, 56 ); List<String> argList = new ArrayList<>(); String key = "number"; for ( int value : expectedValues ) { argList.add( "--" + key ); argList.add( String.valueOf( value ) ); } Args args = Args.parse( argList.toArray( new String[argList.size()] ) ); // WHEN assertThrows( IllegalArgumentException.class, () -> args.get( key ) ); Collection<Integer> numbers = args.interpretOptions( key, optional(), toInt() ); // THEN assertEquals( expectedValues, numbers ); }
@Deprecated public static Args parse( String...args ) { return withFlags().parse( args ); }