Java CommandFactory类代码示例

import org.apache.hadoop.fs.shell.CommandFactory; //导入依赖的package包/类
@Test
public void testExceptionNullMessage() throws Exception {
  final String cmdName = "-cmdExNullMsg";
  final Command cmd = Mockito.mock(Command.class);
  Mockito.when(cmd.run(Mockito.<String>anyVararg())).thenThrow(
      new IllegalArgumentException());
  Mockito.when(cmd.getUsage()).thenReturn(cmdName);

  final CommandFactory cmdFactory = Mockito.mock(CommandFactory.class);
  final String[] names = {cmdName};
  Mockito.when(cmdFactory.getNames()).thenReturn(names);
  Mockito.when(cmdFactory.getInstance(cmdName)).thenReturn(cmd);

  FsShell shell = new FsShell(new Configuration());
  shell.commandFactory = cmdFactory;
  try (GenericTestUtils.SystemErrCapturer capture =
           new GenericTestUtils.SystemErrCapturer()) {
    ToolRunner.run(shell, new String[]{cmdName});
    Assert.assertThat(capture.getOutput(),
        StringContains.containsString(cmdName
            + ": Null exception message"));
  }
}
 

import org.apache.hadoop.fs.shell.CommandFactory; //导入依赖的package包/类
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);
  }
}
 

import org.apache.hadoop.fs.shell.CommandFactory; //导入依赖的package包/类
@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();

    });

}
 

import org.apache.hadoop.fs.shell.CommandFactory; //导入依赖的package包/类
public static void registerCommands(CommandFactory factory) {
  // Register all commands of Erasure CLI, with a '-' at the beginning in name
  // of the command.
  factory.addClass(SetECPolicyCommand.class, "-" + SetECPolicyCommand.NAME);
  factory.addClass(GetECPolicyCommand.class, "-"
      + GetECPolicyCommand.NAME);
  factory.addClass(ListPolicies.class, "-" + ListPolicies.NAME);
}
 

import org.apache.hadoop.fs.shell.CommandFactory; //导入依赖的package包/类
/**
 * Register the permission related commands with the factory
 * @param factory the command factory
 */
public static void registerCommands(CommandFactory factory) {
  factory.addClass(Chmod.class, "-chmod");
  factory.addClass(Chown.class, "-chown");
  factory.addClass(Chgrp.class, "-chgrp");
}
 

import org.apache.hadoop.fs.shell.CommandFactory; //导入依赖的package包/类
@Override
protected void registerCommands(CommandFactory factory) {
  factory.addClass(InterruptCommand.class, "-testInterrupt");
}
 

import org.apache.hadoop.fs.shell.CommandFactory; //导入依赖的package包/类
private static Command getCommandInstance(String cmdName, Configuration conf) {
    final CommandFactory commandFactory = new CommandFactory(conf);
    FsCommand.registerCommands(commandFactory);
    return commandFactory.getInstance(cmdName, conf);
}
 

import org.apache.hadoop.fs.shell.CommandFactory; //导入依赖的package包/类
@Override
protected void registerCommands(CommandFactory factory) {
  factory.registerCommands(ECCommand.class);
}
 

import org.apache.hadoop.fs.shell.CommandFactory; //导入依赖的package包/类
@Override
protected void registerCommands(CommandFactory factory) {
    factory.registerCommands(FsCommand.class);
}
 

import org.apache.hadoop.fs.shell.CommandFactory; //导入依赖的package包/类
public CommandFactoryWithIO(CommandFactory commandFactory, PrintStream out, PrintStream err) {
    this.commandFactory = commandFactory;
    this.out = out;
    this.err = err;
}
 

import org.apache.hadoop.fs.shell.CommandFactory; //导入依赖的package包/类
public static void registerCommands(CommandFactory factory) {
  factory.addClass(TRmr.class, "-rmr");
  factory.addClass(Expunge.class, "-expunge");
}
 

import org.apache.hadoop.fs.shell.CommandFactory; //导入依赖的package包/类
/**
 * Set the command factory.
 *
 * @param factory {@link CommandFactory}
 */
public void setCommandFactory(CommandFactory factory) {
  this.commandFactory = factory;
}
 

import org.apache.hadoop.fs.shell.CommandFactory; //导入依赖的package包/类
/**
 * Return the command factory.
 *
 * @return {@link CommandFactory}
 */
public CommandFactory getCommandFactory() {
  return this.commandFactory;
}
 

import org.apache.hadoop.fs.shell.CommandFactory; //导入依赖的package包/类
/**
 * Register the names for the count command
 * 
 * @param factory the command factory that will instantiate this class
 */
public static void registerCommands(CommandFactory factory) {
  factory.addClass(Find.class, "-find");
}