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; }
@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() ); }
@Test void shouldHandleMixtureOfFlagsAndOrphanParams() { // Given Args args = Args.withFlags( "big", "soft", "saysMeow" ).parse( "-big", "-size=120", "-soft=true", "withStripes", "-saysMeow=false", "-name=ShereKhan", "badTiger" ); // When List<String> orphans = args.orphans(); // Then assertEquals( Arrays.asList( "withStripes", "badTiger" ), orphans ); assertEquals( 120, args.getNumber( "size", 0 ).intValue() ); assertEquals( "ShereKhan", args.get( "name" ) ); assertTrue( args.getBoolean( "big", false, true ) ); assertTrue( args.getBoolean( "soft", false, false ) ); assertFalse( args.getBoolean( "saysMeow", true, true ) ); }
TxFilter txFilter = parseTxFilter( arguments.get( ARG_TXFILTER, null ) ); PrintStream out = System.out; boolean redirectsToFile = arguments.getBoolean( ARG_TOFILE );
public Optional<File> configFile() { return Optional.ofNullable( args.get( CONFIG_DIR_ARG ) ) .map( dirPath -> new File( dirPath, Config.DEFAULT_CONFIG_FILE_NAME ) ); }
@Test void testInterleavedEqualsArgsAndSplitKeyValue() { String[] line = { "-host=localhost", "-v", "--port", "1234", "param1", "-name=Something", "param2" }; Args args = Args.parse( line ); assertEquals( "localhost", args.get( "host", null ) ); assertTrue( args.has( "v" ) ); assertEquals( 1234, args.getNumber( "port", null ).intValue() ); assertEquals( "Something", args.get( "name", null ) ); assertEquals( 2, args.orphans().size() ); assertEquals( "param1", args.orphans().get( 0 ) ); assertEquals( "param2", args.orphans().get( 1 ) ); }
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 ); }
private static long parseNumberOrUnlimited( Args args, Options option ) { String value = args.get( option.key(), option.defaultValue().toString() ); return UNLIMITED.equals( value ) ? BadCollector.UNLIMITED_TOLERANCE : Long.parseLong( value ); }
@Test void shouldHandleFlagSpecifiedAsLastArgument() { // Given Args args = Args.withFlags( "flag1", "flag2" ).parse( "-key=Foo", "-flag1", "false", "-value", "Bar", "-flag2", "false" ); // When List<String> orphans = args.orphans(); // Then assertTrue( orphans.isEmpty(), "Orphan args expected to be empty, but were: " + orphans ); assertEquals( "Foo", args.get( "key" ) ); assertEquals( "Bar", args.get( "value" ) ); assertFalse( args.getBoolean( "flag1", true ) ); assertFalse( args.getBoolean( "flag2", true ) ); }
@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 ); }
private static long parsePid( Args args ) throws CommandFailed { if ( args.has( PID_KEY ) ) { try { return Long.parseLong( args.get( PID_KEY, "" ) ); } catch ( NumberFormatException e ) { throw new CommandFailed( "Unable to parse --" + PID_KEY, e ); } } return NO_PID; }
private static Config readConfiguration( Args arguments ) throws ToolFailureException { String configFilePath = arguments.get( CONFIG, null ); if ( configFilePath != null ) { File configFile = new File( configFilePath ); try { return Config.fromFile( configFile ).build(); } catch ( Exception e ) { throw new ToolFailureException( String.format( "Could not read configuration file [%s]", configFilePath ), e ); } } return Config.defaults(); }
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; }
@Test void shouldInterpretSingleDashAsValue() { // GIVEN Args args = Args.parse( "-test", "-" ); // WHEN String value = args.get( "test" ); // THEN assertEquals( "-", value ); } }
@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 ); }
private static Header parseNodeHeader( Args args, IdType idType, Extractors extractors, Groups groups ) { String definition = args.get( "node-header", null ); if ( definition == null ) { return DataGeneratorInput.bareboneNodeHeader( idType, extractors ); } Configuration config = Configuration.COMMAS; return DataFactories.defaultFormatNodeFileHeader().create( seeker( definition, config ), config, idType, groups ); }
@Test void testParameterWithDashValue() { String [] line = { "-file", "-" }; Args args = Args.parse( line ); assertEquals( 1, args.asMap().size() ); assertEquals( "-", args.get( "file", null ) ); assertTrue( args.orphans().isEmpty() ); }
@Override public long maxMemoryUsage() { String custom = args.get( ImportTool.Options.MAX_MEMORY.key(), (String) ImportTool.Options.MAX_MEMORY.defaultValue() ); return custom != null ? ImportTool.parseMaxMemory( custom ) : DEFAULT.maxMemoryUsage(); } };
private static Header parseRelationshipHeader( Args args, IdType idType, Extractors extractors, Groups groups ) { String definition = args.get( "relationship-header", null ); if ( definition == null ) { return DataGeneratorInput.bareboneRelationshipHeader( idType, extractors ); } Configuration config = Configuration.COMMAS; return DataFactories.defaultFormatRelationshipFileHeader().create( seeker( definition, config ), config, idType, groups ); }