org.apache.hadoop.fs.shell.FsCommand Java Examples

/**
 * Tests valid and invalid group arguments to chgrp.
 */
@Test
public void testChgrpGroupValidity() {
  // This test only covers argument parsing, so override to skip processing.
  FsCommand chgrp = new FsShellPermissions.Chgrp() {
    @Override
    protected void processArgument(PathData item) {
    }
  };
  chgrp.setConf(new Configuration());

  // The following are valid (no exception expected).
  chgrp.run("group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chgrp, "Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chgrp, ":gr#oup", "/path");
  assertIllegalArguments(chgrp, ":gr%oup", "/path");
}
 

/**
 * Tests valid and invalid group arguments to chgrp.
 */
@Test
public void testChgrpGroupValidity() {
  // This test only covers argument parsing, so override to skip processing.
  FsCommand chgrp = new FsShellPermissions.Chgrp() {
    @Override
    protected void processArgument(PathData item) {
    }
  };
  chgrp.setConf(new Configuration());

  // The following are valid (no exception expected).
  chgrp.run("group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chgrp, "Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chgrp, ":gr#oup", "/path");
  assertIllegalArguments(chgrp, ":gr%oup", "/path");
}
 

protected void registerCommands(CommandFactory factory) {
  // TODO: DFSAdmin subclasses FsShell so need to protect the command
  // registration.  This class should morph into a base class for
  // commands, and then this method can be abstract
  if (this.getClass().equals(OzoneFsShell.class)) {
    factory.registerCommands(FsCommand.class);
  }
}
 

@Test
@Ignore
public void generateMethods() {
    final CommandFactory commandFactory = new CommandFactory(new Configuration());
    FsCommand.registerCommands(commandFactory);
    final String[] names = commandFactory.getNames();
    final String collect = Arrays.stream(names).map(item -> "\"" + item.replace("-", "") + "\"").collect(Collectors.joining(","));
    System.out.println(collect);
    Arrays.stream(names).map(commandFactory::getInstance).forEach(item -> {
        String description = "";
        final String[] sentences = item.getDescription().split("\\.");
        if (sentences.length == 0) {
            description = item.getDescription();
        } else {
            description = sentences[0] + ".";
        }


        String cliCommand = String.format("@CliCommand(value = {\"%s\", \"hdfs dfs -%s\"}, help = \"%s\")", item.getCommandName(), item.getCommandName(), description);
        String content = String.format("    public String %s(\n" +
                "            @CliOption(key = {\"\"}, help = \"%s\") String path\n" +
                "    ) {\n" +
                "        return runCommand(\"%s\", path);\n" +
                "    }\n", item.getCommandName(), description, item.getCommandName());

        System.out.println(cliCommand);
        System.out.println(content);

        System.out.println();

    });

}
 

protected void registerCommands(CommandFactory factory) {
  // TODO: DFSAdmin subclasses FsShell so need to protect the command
  // registration.  This class should morph into a base class for
  // commands, and then this method can be abstract
  if (this.getClass().equals(FsShell.class)) {
    factory.registerCommands(FsCommand.class);
  }
}
 

/**
 * Tests combinations of valid and invalid user and group arguments to chown.
 */
@Test
public void testChownUserAndGroupValidity() {
  // This test only covers argument parsing, so override to skip processing.
  FsCommand chown = new FsShellPermissions.Chown() {
    @Override
    protected void processArgument(PathData item) {
    }
  };
  chown.setConf(new Configuration());

  // The following are valid (no exception expected).
  chown.run("user", "/path");
  chown.run("user:group", "/path");
  chown.run(":group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chown, "User With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:group", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:Group With Spaces",
    "/path");
  assertValidArgumentsOnWindows(chown, "user:Group With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, ":Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chown, "us!er", "/path");
  assertIllegalArguments(chown, "us^er", "/path");
  assertIllegalArguments(chown, "user:gr#oup", "/path");
  assertIllegalArguments(chown, "user:gr%oup", "/path");
  assertIllegalArguments(chown, ":gr#oup", "/path");
  assertIllegalArguments(chown, ":gr%oup", "/path");
}
 

/**
 * Asserts that for the given command, the given arguments are considered
 * invalid.  The expectation is that the command will throw
 * IllegalArgumentException.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertIllegalArguments(FsCommand cmd, String... args) {
  try {
    cmd.run(args);
    fail("Expected IllegalArgumentException from args: " +
      Arrays.toString(args));
  } catch (IllegalArgumentException e) {
  }
}
 

/**
 * Asserts that for the given command, the given arguments are considered valid
 * on Windows, but invalid elsewhere.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertValidArgumentsOnWindows(FsCommand cmd,
    String... args) {
  if (Shell.WINDOWS) {
    cmd.run(args);
  } else {
    assertIllegalArguments(cmd, args);
  }
}
 

protected void registerCommands(CommandFactory factory) {
  // TODO: DFSAdmin subclasses FsShell so need to protect the command
  // registration.  This class should morph into a base class for
  // commands, and then this method can be abstract
  if (this.getClass().equals(FsShell.class)) {
    factory.registerCommands(FsCommand.class);
  }
}
 

/**
 * Tests combinations of valid and invalid user and group arguments to chown.
 */
@Test
public void testChownUserAndGroupValidity() {
  // This test only covers argument parsing, so override to skip processing.
  FsCommand chown = new FsShellPermissions.Chown() {
    @Override
    protected void processArgument(PathData item) {
    }
  };
  chown.setConf(new Configuration());

  // The following are valid (no exception expected).
  chown.run("user", "/path");
  chown.run("user:group", "/path");
  chown.run(":group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chown, "User With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:group", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:Group With Spaces",
    "/path");
  assertValidArgumentsOnWindows(chown, "user:Group With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, ":Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chown, "us!er", "/path");
  assertIllegalArguments(chown, "us^er", "/path");
  assertIllegalArguments(chown, "user:gr#oup", "/path");
  assertIllegalArguments(chown, "user:gr%oup", "/path");
  assertIllegalArguments(chown, ":gr#oup", "/path");
  assertIllegalArguments(chown, ":gr%oup", "/path");
}
 

/**
 * Asserts that for the given command, the given arguments are considered
 * invalid.  The expectation is that the command will throw
 * IllegalArgumentException.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertIllegalArguments(FsCommand cmd, String... args) {
  try {
    cmd.run(args);
    fail("Expected IllegalArgumentException from args: " +
      Arrays.toString(args));
  } catch (IllegalArgumentException e) {
  }
}
 

/**
 * Asserts that for the given command, the given arguments are considered valid
 * on Windows, but invalid elsewhere.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertValidArgumentsOnWindows(FsCommand cmd,
    String... args) {
  if (Shell.WINDOWS) {
    cmd.run(args);
  } else {
    assertIllegalArguments(cmd, args);
  }
}
 

private static Command getCommandInstance(String cmdName, Configuration conf) {
    final CommandFactory commandFactory = new CommandFactory(conf);
    FsCommand.registerCommands(commandFactory);
    return commandFactory.getInstance(cmdName, conf);
}