Apache
/
hadoop
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

HADOOP-8989. hadoop fs -find feature (Jonathan Allen via aw)

This commit is contained in:
Allen Wittenauer 2014-11-13 08:20:43 -08:00
parent 81dc0ac6dc
commit ba879a5dad
27 changed files with 4013 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hadoop-common-project/hadoop-common/CHANGES.txt
View File

@ -360,6 +360,8 @@ Release 2.7.0 - UNRELEASED
HADOOP-7984. Add hadoop --loglevel option to change log level.
(Akira AJISAKA via cnauroth)
HADOOP-8989. hadoop fs -find feature (Jonathan Allen via aw)
IMPROVEMENTS
HADOOP-11156. DelegateToFileSystem should implement

28
hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/Command.java
View File

@ -65,6 +65,8 @@ abstract public class Command extends Configured {
public PrintStream out = System.out;
/** allows stderr to be captured if necessary */
public PrintStream err = System.err;
/** allows the command factory to be used if necessary */
private CommandFactory commandFactory = null;
/** Constructor */
protected Command() {
@ -121,6 +123,15 @@ abstract public class Command extends Configured {
return exitCode;
}
/** sets the command factory for later use */
public void setCommandFactory(CommandFactory factory) {
this.commandFactory = factory;
}
/** retrieves the command factory */
protected CommandFactory getCommandFactory() {
return this.commandFactory;
}
/**
* Invokes the command handler. The default behavior is to process options,
* expand arguments, and then process each argument.
@ -308,7 +319,7 @@ abstract public class Command extends Configured {
for (PathData item : items) {
try {
processPath(item);
if (recursive && item.stat.isDirectory()) {
if (recursive && isPathRecursable(item)) {
recursePath(item);
}
postProcessPath(item);
@ -318,6 +329,21 @@ abstract public class Command extends Configured {
}
}
/**
* Determines whether a {@link PathData} item is recursable. Default
* implementation is to recurse directories but can be overridden to recurse
* through symbolic links.
*
* @param item
* a {@link PathData} object
* @return true if the item is recursable, false otherwise
* @throws IOException
* if anything goes wrong in the user-implementation
*/
protected boolean isPathRecursable(PathData item) throws IOException {
return item.stat.isDirectory();
}
/**
* Hook for commands to implement an operation to be applied on each
* path for the command. Note implementation of this method is optional

1
hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/CommandFactory.java
View File

@ -124,6 +124,7 @@ public class CommandFactory extends Configured {
if (cmdClass != null) {
instance = ReflectionUtils.newInstance(cmdClass, conf);
instance.setName(cmdName);
instance.setCommandFactory(this);
}
}
return instance;

2
hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/FsCommand.java
View File

@ -25,6 +25,7 @@ import org.apache.hadoop.classification.InterfaceStability;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FsShellPermissions;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.shell.find.Find;
/**
* Base class for all "hadoop fs" commands
@ -48,6 +49,7 @@ abstract public class FsCommand extends Command {
factory.registerCommands(Count.class);
factory.registerCommands(Delete.class);
factory.registerCommands(Display.class);
factory.registerCommands(Find.class);
factory.registerCommands(FsShellPermissions.class);
factory.registerCommands(FsUsage.class);
factory.registerCommands(Ls.class);

84
hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/find/And.java Normal file
View File

@ -0,0 +1,84 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import java.io.IOException;
import java.util.Deque;
import org.apache.hadoop.fs.shell.PathData;
/**
* Implements the -a (and) operator for the
* {@link org.apache.hadoop.fs.shell.find.Find} command.
*/
final class And extends BaseExpression {
/** Registers this expression with the specified factory. */
public static void registerExpression(ExpressionFactory factory)
throws IOException {
factory.addClass(And.class, "-a");
factory.addClass(And.class, "-and");
}
private static final String[] USAGE = { "expression -a expression",
"expression -and expression", "expression expression" };
private static final String[] HELP = {
"Logical AND operator for joining two expressions. Returns",
"true if both child expressions return true. Implied by the",
"juxtaposition of two expressions and so does not need to be",
"explicitly specified. The second expression will not be",
"applied if the first fails." };
public And() {
super();
setUsage(USAGE);
setHelp(HELP);
}
/**
* Applies child expressions to the {@link PathData} item. If all pass then
* returns {@link Result#PASS} else returns the result of the first
* non-passing expression.
*/
@Override
public Result apply(PathData item, int depth) throws IOException {
Result result = Result.PASS;
for (Expression child : getChildren()) {
Result childResult = child.apply(item, -1);
result = result.combine(childResult);
if (!result.isPass()) {
return result;
}
}
return result;
}
@Override
public boolean isOperator() {
return true;
}
@Override
public int getPrecedence() {
return 200;
}
@Override
public void addChildren(Deque<Expression> expressions) {
addChildren(expressions, 2);
}
}

302
hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/find/BaseExpression.java Normal file
View File

@ -0,0 +1,302 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import java.io.IOException;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
import org.apache.hadoop.conf.Configurable;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.shell.PathData;
/**
* Abstract expression for use in the
* {@link org.apache.hadoop.fs.shell.find.Find} command. Provides default
* behavior for a no-argument primary expression.
*/
public abstract class BaseExpression implements Expression, Configurable {
private String[] usage = { "Not yet implemented" };
private String[] help = { "Not yet implemented" };
/** Sets the usage text for this {@link Expression} */
protected void setUsage(String[] usage) {
this.usage = usage;
}
/** Sets the help text for this {@link Expression} */
protected void setHelp(String[] help) {
this.help = help;
}
@Override
public String[] getUsage() {
return this.usage;
}
@Override
public String[] getHelp() {
return this.help;
}
@Override
public void setOptions(FindOptions options) throws IOException {
this.options = options;
for (Expression child : getChildren()) {
child.setOptions(options);
}
}
@Override
public void prepare() throws IOException {
for (Expression child : getChildren()) {
child.prepare();
}
}
@Override
public void finish() throws IOException {
for (Expression child : getChildren()) {
child.finish();
}
}
/** Options passed in from the {@link Find} command. */
private FindOptions options;
/** Hadoop configuration. */
private Configuration conf;
/** Arguments for this expression. */
private LinkedList<String> arguments = new LinkedList<String>();
/** Children of this expression. */
private LinkedList<Expression> children = new LinkedList<Expression>();
/** Return the options to be used by this expression. */
protected FindOptions getOptions() {
return (this.options == null) ? new FindOptions() : this.options;
}
@Override
public void setConf(Configuration conf) {
this.conf = conf;
}
@Override
public Configuration getConf() {
return this.conf;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(getClass().getSimpleName());
sb.append("(");
boolean firstArg = true;
for (String arg : getArguments()) {
if (!firstArg) {
sb.append(",");
} else {
firstArg = false;
}
sb.append(arg);
}
sb.append(";");
firstArg = true;
for (Expression child : getChildren()) {
if (!firstArg) {
sb.append(",");
} else {
firstArg = false;
}
sb.append(child.toString());
}
sb.append(")");
return sb.toString();
}
@Override
public boolean isAction() {
for (Expression child : getChildren()) {
if (child.isAction()) {
return true;
}
}
return false;
}
@Override
public boolean isOperator() {
return false;
}
/**
* Returns the arguments of this expression
*
* @return list of argument strings
*/
protected List<String> getArguments() {
return this.arguments;
}
/**
* Returns the argument at the given position (starting from 1).
*
* @param position
* argument to be returned
* @return requested argument
* @throws IOException
* if the argument doesn't exist or is null
*/
protected String getArgument(int position) throws IOException {
if (position > this.arguments.size()) {
throw new IOException("Missing argument at " + position);
}
String argument = this.arguments.get(position - 1);
if (argument == null) {
throw new IOException("Null argument at position " + position);
}
return argument;
}
/**
* Returns the children of this expression.
*
* @return list of child expressions
*/
protected List<Expression> getChildren() {
return this.children;
}
@Override
public int getPrecedence() {
return 0;
}
@Override
public void addChildren(Deque<Expression> exprs) {
// no children by default, will be overridden by specific expressions.
}
/**
* Add a specific number of children to this expression. The children are
* popped off the head of the expressions.
*
* @param exprs
* deque of expressions from which to take the children
* @param count
* number of children to be added
*/
protected void addChildren(Deque<Expression> exprs, int count) {
for (int i = 0; i < count; i++) {
addChild(exprs.pop());
}
}
/**
* Add a single argument to this expression. The argument is popped off the
* head of the expressions.
*
* @param expr
* child to add to the expression
*/
private void addChild(Expression expr) {
children.push(expr);
}
@Override
public void addArguments(Deque<String> args) {
// no children by default, will be overridden by specific expressions.
}
/**
* Add a specific number of arguments to this expression. The children are
* popped off the head of the expressions.
*
* @param args
* deque of arguments from which to take the argument
* @param count
* number of children to be added
*/
protected void addArguments(Deque<String> args, int count) {
for (int i = 0; i < count; i++) {
addArgument(args.pop());
}
}
/**
* Add a single argument to this expression. The argument is popped off the
* head of the expressions.
*
* @param arg
* argument to add to the expression
*/
protected void addArgument(String arg) {
arguments.add(arg);
}
/**
* Returns the {@link FileStatus} from the {@link PathData} item. If the
* current options require links to be followed then the returned file status
* is that of the linked file.
*
* @param item
* PathData
* @param depth
* current depth in the process directories
* @return FileStatus
*/
protected FileStatus getFileStatus(PathData item, int depth)
throws IOException {
FileStatus fileStatus = item.stat;
if (fileStatus.isSymlink()) {
if (options.isFollowLink() || (options.isFollowArgLink() &&
(depth == 0))) {
Path linkedFile = item.fs.resolvePath(fileStatus.getSymlink());
fileStatus = getFileSystem(item).getFileStatus(linkedFile);
}
}
return fileStatus;
}
/**
* Returns the {@link Path} from the {@link PathData} item.
*
* @param item
* PathData
* @return Path
*/
protected Path getPath(PathData item) throws IOException {
return item.path;
}
/**
* Returns the {@link FileSystem} associated with the {@link PathData} item.
*
* @param item PathData
* @return FileSystem
*/
protected FileSystem getFileSystem(PathData item) throws IOException {
return item.fs;
}
}

107
hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/find/Expression.java Normal file
View File

@ -0,0 +1,107 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import java.io.IOException;
import java.util.Deque;
import org.apache.hadoop.fs.shell.PathData;
/**
* Interface describing an expression to be used in the
* {@link org.apache.hadoop.fs.shell.find.Find} command.
*/
public interface Expression {
/**
* Set the options for this expression, called once before processing any
* items.
*/
public void setOptions(FindOptions options) throws IOException;
/**
* Prepares the expression for execution, called once after setting options
* and before processing any options.
* @throws IOException
*/
public void prepare() throws IOException;
/**
* Apply the expression to the specified item, called once for each item.
*
* @param item {@link PathData} item to be processed
* @param depth distance of the item from the command line argument
* @return {@link Result} of applying the expression to the item
*/
public Result apply(PathData item, int depth) throws IOException;
/**
* Finishes the expression, called once after processing all items.
*
* @throws IOException
*/
public void finish() throws IOException;
/**
* Returns brief usage instructions for this expression. Multiple items should
* be returned if there are multiple ways to use this expression.
*
* @return array of usage instructions
*/
public String[] getUsage();
/**
* Returns a description of the expression for use in help. Multiple lines
* should be returned array items. Lines should be formated to 60 characters
* or less.
*
* @return array of description lines
*/
public String[] getHelp();
/**
* Indicates whether this expression performs an action, i.e. provides output
* back to the user.
*/
public boolean isAction();
/** Identifies the expression as an operator rather than a primary. */
public boolean isOperator();
/**
* Returns the precedence of this expression
* (only applicable to operators).
*/
public int getPrecedence();
/**
* Adds children to this expression. Children are popped from the head of the
* deque.
*
* @param expressions
* deque of expressions from which to take the children
*/
public void addChildren(Deque<Expression> expressions);
/**
* Adds arguments to this expression. Arguments are popped from the head of
* the deque and added to the front of the child list, ie last child added is
* the first evaluated.
* @param args deque of arguments from which to take expression arguments
*/
public void addArguments(Deque<String> args);
}

156
hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/find/ExpressionFactory.java Normal file
View File

@ -0,0 +1,156 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.util.ReflectionUtils;
import org.apache.hadoop.util.StringUtils;
/**
* Factory class for registering and searching for expressions for use in the
* {@link org.apache.hadoop.fs.shell.find.Find} command.
*/
final class ExpressionFactory {
private static final String REGISTER_EXPRESSION_METHOD = "registerExpression";
private Map<String, Class<? extends Expression>> expressionMap =
new HashMap<String, Class<? extends Expression>>();
private static final ExpressionFactory INSTANCE = new ExpressionFactory();
static ExpressionFactory getExpressionFactory() {
return INSTANCE;
}
/**
* Private constructor to ensure singleton.
*/
private ExpressionFactory() {
}
/**
* Invokes "static void registerExpression(FindExpressionFactory)" on the
* given class. This method abstracts the contract between the factory and the
* expression class. Do not assume that directly invoking registerExpression
* on the given class will have the same effect.
*
* @param expressionClass
* class to allow an opportunity to register
*/
void registerExpression(Class<? extends Expression> expressionClass) {
try {
Method register = expressionClass.getMethod(REGISTER_EXPRESSION_METHOD,
ExpressionFactory.class);
if (register != null) {
register.invoke(null, this);
}
} catch (Exception e) {
throw new RuntimeException(StringUtils.stringifyException(e));
}
}
/**
* Register the given class as handling the given list of expression names.
*
* @param expressionClass
* the class implementing the expression names
* @param names
* one or more command names that will invoke this class
* @throws IOException
* if the expression is not of an expected type
*/
void addClass(Class<? extends Expression> expressionClass,
String... names) throws IOException {
for (String name : names)
expressionMap.put(name, expressionClass);
}
/**
* Determines whether the given expression name represents and actual
* expression.
*
* @param expressionName
* name of the expression
* @return true if expressionName represents an expression
*/
boolean isExpression(String expressionName) {
return expressionMap.containsKey(expressionName);
}
/**
* Get an instance of the requested expression
*
* @param expressionName
* name of the command to lookup
* @param conf
* the Hadoop configuration
* @return the {@link Expression} or null if the expression is unknown
*/
Expression getExpression(String expressionName, Configuration conf) {
if (conf == null)
throw new NullPointerException("configuration is null");
Class<? extends Expression> expressionClass = expressionMap
.get(expressionName);
Expression instance = createExpression(expressionClass, conf);
return instance;
}
/**
* Creates an instance of the requested {@link Expression} class.
*
* @param expressionClass
* {@link Expression} class to be instantiated
* @param conf
* the Hadoop configuration
* @return a new instance of the requested {@link Expression} class
*/
Expression createExpression(
Class<? extends Expression> expressionClass, Configuration conf) {
Expression instance = null;
if (expressionClass != null) {
instance = ReflectionUtils.newInstance(expressionClass, conf);
}
return instance;
}
/**
* Creates an instance of the requested {@link Expression} class.
*
* @param expressionClassname
* name of the {@link Expression} class to be instantiated
* @param conf
* the Hadoop configuration
* @return a new instance of the requested {@link Expression} class
*/
Expression createExpression(String expressionClassname,
Configuration conf) {
try {
Class<? extends Expression> expressionClass = Class.forName(
expressionClassname).asSubclass(Expression.class);
return createExpression(expressionClass, conf);
} catch (ClassNotFoundException e) {
throw new IllegalArgumentException("Invalid classname "
+ expressionClassname);
}
}
}

144
hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/find/FilterExpression.java Normal file
View File

@ -0,0 +1,144 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import java.io.IOException;
import java.util.Deque;
import org.apache.hadoop.conf.Configurable;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.shell.PathData;
/**
* Provides an abstract composition filter for the {@link Expression} interface.
* Allows other {@link Expression} implementations to be reused without
* inheritance.
*/
public abstract class FilterExpression implements Expression, Configurable {
protected Expression expression;
protected FilterExpression(Expression expression) {
this.expression = expression;
}
@Override
public void setOptions(FindOptions options) throws IOException {
if (expression != null) {
expression.setOptions(options);
}
}
@Override
public void prepare() throws IOException {
if (expression != null) {
expression.prepare();
}
}
@Override
public Result apply(PathData item, int depth) throws IOException {
if (expression != null) {
return expression.apply(item, -1);
}
return Result.PASS;
}
@Override
public void finish() throws IOException {
if (expression != null) {
expression.finish();
}
}
@Override
public String[] getUsage() {
if (expression != null) {
return expression.getUsage();
}
return null;
}
@Override
public String[] getHelp() {
if (expression != null) {
return expression.getHelp();
}
return null;
}
@Override
public boolean isAction() {
if (expression != null) {
return expression.isAction();
}
return false;
}
@Override
public boolean isOperator() {
if (expression != null) {
return expression.isOperator();
}
return false;
}
@Override
public int getPrecedence() {
if (expression != null) {
return expression.getPrecedence();
}
return -1;
}
@Override
public void addChildren(Deque<Expression> expressions) {
if (expression != null) {
expression.addChildren(expressions);
}
}
@Override
public void addArguments(Deque<String> args) {
if (expression != null) {
expression.addArguments(args);
}
}
@Override
public void setConf(Configuration conf) {
if (expression instanceof Configurable) {
((Configurable) expression).setConf(conf);
}
}
@Override
public Configuration getConf() {
if (expression instanceof Configurable) {
return ((Configurable) expression).getConf();
}
return null;
}
@Override
public String toString() {
if (expression != null) {
return getClass().getSimpleName() + "-" + expression.toString();
}
return getClass().getSimpleName();
}
}

444
hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/find/Find.java Normal file
View File

@ -0,0 +1,444 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import org.apache.hadoop.classification.InterfaceAudience;
import org.apache.hadoop.classification.InterfaceStability;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.shell.CommandFactory;
import org.apache.hadoop.fs.shell.CommandFormat;
import org.apache.hadoop.fs.shell.FsCommand;
import org.apache.hadoop.fs.shell.PathData;
@InterfaceAudience.Private
@InterfaceStability.Unstable
/**
* Implements a Hadoop find command.
*/
public class Find extends FsCommand {
/**
* 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");
}
public static final String NAME = "find";
public static final String USAGE = "<path> ... <expression> ...";
public static final String DESCRIPTION;
private static String[] HELP =
{ "Finds all files that match the specified expression and",
"applies selected actions to them. If no <path> is specified",
"then defaults to the current working directory. If no",
"expression is specified then defaults to -print."
};
private static final String OPTION_FOLLOW_LINK = "L";
private static final String OPTION_FOLLOW_ARG_LINK = "H";
/** List of expressions recognized by this command. */
@SuppressWarnings("rawtypes")
private static final Class[] EXPRESSIONS;
static {
// Initialize the static variables.
EXPRESSIONS = new Class[] {
// Operator Expressions
And.class,
// Action Expressions
Print.class,
// Navigation Expressions
// Matcher Expressions
Name.class };
DESCRIPTION = buildDescription(ExpressionFactory.getExpressionFactory());
// Register the expressions with the expression factory.
registerExpressions(ExpressionFactory.getExpressionFactory());
}
/** Options for use in this command */
private FindOptions options;
/** Root expression for this instance of the command. */
private Expression rootExpression;
/** Set of path items returning a {@link Result#STOP} result. */
private HashSet<Path> stopPaths = new HashSet<Path>();
/** Register the expressions with the expression factory. */
@SuppressWarnings("unchecked")
private static void registerExpressions(ExpressionFactory factory) {
for (Class<? extends Expression> exprClass : EXPRESSIONS) {
factory.registerExpression(exprClass);
}
}
/** Build the description used by the help command. */
@SuppressWarnings("unchecked")
private static String buildDescription(ExpressionFactory factory) {
ArrayList<Expression> operators = new ArrayList<Expression>();
ArrayList<Expression> primaries = new ArrayList<Expression>();
for (Class<? extends Expression> exprClass : EXPRESSIONS) {
Expression expr = factory.createExpression(exprClass, null);
if (expr.isOperator()) {
operators.add(expr);
} else {
primaries.add(expr);
}
}
Collections.sort(operators, new Comparator<Expression>() {
@Override
public int compare(Expression arg0, Expression arg1) {
return arg0.getClass().getName().compareTo(arg1.getClass().getName());
}
});
Collections.sort(primaries, new Comparator<Expression>() {
@Override
public int compare(Expression arg0, Expression arg1) {
return arg0.getClass().getName().compareTo(arg1.getClass().getName());
}
});
StringBuilder sb = new StringBuilder();
for (String line : HELP) {
sb.append(line).append("\n");
}
sb.append("\n");
sb.append("The following primary expressions are recognised:\n");
for (Expression expr : primaries) {
for (String line : expr.getUsage()) {
sb.append(" ").append(line).append("\n");
}
for (String line : expr.getHelp()) {
sb.append(" ").append(line).append("\n");
}
sb.append("\n");
}
sb.append("The following operators are recognised:\n");
for (Expression expr : operators) {
for (String line : expr.getUsage()) {
sb.append(" ").append(line).append("\n");
}
for (String line : expr.getHelp()) {
sb.append(" ").append(line).append("\n");
}
sb.append("\n");
}
return sb.toString();
}
/** Default constructor for the Find command. */
public Find() {
setRecursive(true);
}
@Override
protected void processOptions(LinkedList<String> args) throws IOException {
CommandFormat cf =
new CommandFormat(1, Integer.MAX_VALUE, OPTION_FOLLOW_LINK,
OPTION_FOLLOW_ARG_LINK, null);
cf.parse(args);
if (cf.getOpt(OPTION_FOLLOW_LINK)) {
getOptions().setFollowLink(true);
} else if (cf.getOpt(OPTION_FOLLOW_ARG_LINK)) {
getOptions().setFollowArgLink(true);
}
// search for first non-path argument (ie starts with a "-") and capture and
// remove the remaining arguments as expressions
LinkedList<String> expressionArgs = new LinkedList<String>();
Iterator<String> it = args.iterator();
boolean isPath = true;
while (it.hasNext()) {
String arg = it.next();
if (isPath) {
if (arg.startsWith("-")) {
isPath = false;
}
}
if (!isPath) {
expressionArgs.add(arg);
it.remove();
}
}
if (args.isEmpty()) {
args.add(Path.CUR_DIR);
}
Expression expression = parseExpression(expressionArgs);
if (!expression.isAction()) {
Expression and = getExpression(And.class);
Deque<Expression> children = new LinkedList<Expression>();
children.add(getExpression(Print.class));
children.add(expression);
and.addChildren(children);
expression = and;
}
setRootExpression(expression);
}
/**
* Set the root expression for this find.
*
* @param expression
*/
@InterfaceAudience.Private
void setRootExpression(Expression expression) {
this.rootExpression = expression;
}
/**
* Return the root expression for this find.
*
* @return the root expression
*/
@InterfaceAudience.Private
Expression getRootExpression() {
return this.rootExpression;
}
/** Returns the current find options, creating them if necessary. */
@InterfaceAudience.Private
FindOptions getOptions() {
if (options == null) {
options = createOptions();
}
return options;
}
/** Create a new set of find options. */
private FindOptions createOptions() {
FindOptions options = new FindOptions();
options.setOut(out);
options.setErr(err);
options.setIn(System.in);
options.setCommandFactory(getCommandFactory());
options.setConfiguration(getConf());
return options;
}
/** Add the {@link PathData} item to the stop set. */
private void addStop(PathData item) {
stopPaths.add(item.path);
}
/** Returns true if the {@link PathData} item is in the stop set. */
private boolean isStop(PathData item) {
return stopPaths.contains(item.path);
}
/**
* Parse a list of arguments to to extract the {@link Expression} elements.
* The input Deque will be modified to remove the used elements.
*
* @param args arguments to be parsed
* @return list of {@link Expression} elements applicable to this command
* @throws IOException if list can not be parsed
*/
private Expression parseExpression(Deque<String> args) throws IOException {
Deque<Expression> primaries = new LinkedList<Expression>();
Deque<Expression> operators = new LinkedList<Expression>();
Expression prevExpr = getExpression(And.class);
while (!args.isEmpty()) {
String arg = args.pop();
if ("(".equals(arg)) {
Expression expr = parseExpression(args);
primaries.add(expr);
prevExpr = new BaseExpression() {
@Override
public Result apply(PathData item, int depth) throws IOException {
return Result.PASS;
}
}; // stub the previous expression to be a non-op
} else if (")".equals(arg)) {
break;
} else if (isExpression(arg)) {
Expression expr = getExpression(arg);
expr.addArguments(args);
if (expr.isOperator()) {
while (!operators.isEmpty()) {
if (operators.peek().getPrecedence() >= expr.getPrecedence()) {
Expression op = operators.pop();
op.addChildren(primaries);
primaries.push(op);
} else {
break;
}
}
operators.push(expr);
} else {
if (!prevExpr.isOperator()) {
Expression and = getExpression(And.class);
while (!operators.isEmpty()) {
if (operators.peek().getPrecedence() >= and.getPrecedence()) {
Expression op = operators.pop();
op.addChildren(primaries);
primaries.push(op);
} else {
break;
}
}
operators.push(and);
}
primaries.push(expr);
}
prevExpr = expr;
} else {
throw new IOException("Unexpected argument: " + arg);
}
}
while (!operators.isEmpty()) {
Expression operator = operators.pop();
operator.addChildren(primaries);
primaries.push(operator);
}
return primaries.isEmpty() ? getExpression(Print.class) : primaries.pop();
}
/** Returns true if the target is an ancestor of the source. */
private boolean isAncestor(PathData source, PathData target) {
for (Path parent = source.path; (parent != null) && !parent.isRoot();
parent = parent.getParent()) {
if (parent.equals(target.path)) {
return true;
}
}
return false;
}
@Override
protected void recursePath(PathData item) throws IOException {
if (isStop(item)) {
// this item returned a stop result so don't recurse any further
return;
}
if (getDepth() >= getOptions().getMaxDepth()) {
// reached the maximum depth so don't got any further.
return;
}
if (item.stat.isSymlink() && getOptions().isFollowLink()) {
PathData linkedItem =
new PathData(item.stat.getSymlink().toString(), getConf());
if (isAncestor(item, linkedItem)) {
getOptions().getErr().println(
"Infinite loop ignored: " + item.toString() + " -> "
+ linkedItem.toString());
return;
}
if (linkedItem.exists) {
item = linkedItem;
}
}
if (item.stat.isDirectory()) {
super.recursePath(item);
}
}
@Override
protected boolean isPathRecursable(PathData item) throws IOException {
if (item.stat.isDirectory()) {
return true;
}
if (item.stat.isSymlink()) {
PathData linkedItem =
new PathData(item.fs.resolvePath(item.stat.getSymlink()).toString(),
getConf());
if (linkedItem.stat.isDirectory()) {
if (getOptions().isFollowLink()) {
return true;
}
if (getOptions().isFollowArgLink() && (getDepth() == 0)) {
return true;
}
}
}
return false;
}
@Override
protected void processPath(PathData item) throws IOException {
if (getOptions().isDepthFirst()) {
// depth first so leave until post processing
return;
}
applyItem(item);
}
@Override
protected void postProcessPath(PathData item) throws IOException {
if (!getOptions().isDepthFirst()) {
// not depth first so already processed
return;
}
applyItem(item);
}
private void applyItem(PathData item) throws IOException {
if (getDepth() >= getOptions().getMinDepth()) {
Result result = getRootExpression().apply(item, getDepth());
if (Result.STOP.equals(result)) {
addStop(item);
}
}
}
@Override
protected void processArguments(LinkedList<PathData> args)
throws IOException {
Expression expr = getRootExpression();
expr.setOptions(getOptions());
expr.prepare();
super.processArguments(args);
expr.finish();
}
/** Gets a named expression from the factory. */
private Expression getExpression(String expressionName) {
return ExpressionFactory.getExpressionFactory().getExpression(
expressionName, getConf());
}
/** Gets an instance of an expression from the factory. */
private Expression getExpression(
Class<? extends Expression> expressionClass) {
return ExpressionFactory.getExpressionFactory().createExpression(
expressionClass, getConf());
}
/** Asks the factory whether an expression is recognized. */
private boolean isExpression(String expressionName) {
return ExpressionFactory.getExpressionFactory()
.isExpression(expressionName);
}
}

271
hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/find/FindOptions.java Normal file
View File

@ -0,0 +1,271 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.Date;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.shell.CommandFactory;
/**
* Options to be used by the {@link Find} command and its {@link Expression}s.
*/
public class FindOptions {
/** Output stream to be used. */
private PrintStream out;
/** Error stream to be used. */
private PrintStream err;
/** Input stream to be used. */
private InputStream in;
/**
* Indicates whether the expression should be applied to the directory tree
* depth first.
*/
private boolean depthFirst = false;
/** Indicates whether symbolic links should be followed. */
private boolean followLink = false;
/**
* Indicates whether symbolic links specified as command arguments should be
* followed.
*/
private boolean followArgLink = false;
/** Start time of the find process. */
private long startTime = new Date().getTime();
/**
* Depth at which to start applying expressions.
*/
private int minDepth = 0;
/**
* Depth at which to stop applying expressions.
*/
private int maxDepth = Integer.MAX_VALUE;
/** Factory for retrieving command classes. */
private CommandFactory commandFactory;
/** Configuration object. */
private Configuration configuration = new Configuration();
/**
* Sets the output stream to be used.
*
* @param out output stream to be used
*/
public void setOut(PrintStream out) {
this.out = out;
}
/**
* Returns the output stream to be used.
*
* @return output stream to be used
*/
public PrintStream getOut() {
return this.out;
}
/**
* Sets the error stream to be used.
*
* @param err error stream to be used
*/
public void setErr(PrintStream err) {
this.err = err;
}
/**
* Returns the error stream to be used.
*
* @return error stream to be used
*/
public PrintStream getErr() {
return this.err;
}
/**
* Sets the input stream to be used.
*
* @param in input stream to be used
*/
public void setIn(InputStream in) {
this.in = in;
}
/**
* Returns the input stream to be used.
*
* @return input stream to be used
*/
public InputStream getIn() {
return this.in;
}
/**
* Sets flag indicating whether the expression should be applied to the
* directory tree depth first.
*
* @param depthFirst true indicates depth first traversal
*/
public void setDepthFirst(boolean depthFirst) {
this.depthFirst = depthFirst;
}
/**
* Should directory tree be traversed depth first?
*
* @return true indicate depth first traversal
*/
public boolean isDepthFirst() {
return this.depthFirst;
}
/**
* Sets flag indicating whether symbolic links should be followed.
*
* @param followLink true indicates follow links
*/
public void setFollowLink(boolean followLink) {
this.followLink = followLink;
}
/**
* Should symbolic links be follows?
*
* @return true indicates links should be followed
*/
public boolean isFollowLink() {
return this.followLink;
}
/**
* Sets flag indicating whether command line symbolic links should be
* followed.
*
* @param followArgLink true indicates follow links
*/
public void setFollowArgLink(boolean followArgLink) {
this.followArgLink = followArgLink;
}
/**
* Should command line symbolic links be follows?
*
* @return true indicates links should be followed
*/
public boolean isFollowArgLink() {
return this.followArgLink;
}
/**
* Returns the start time of this {@link Find} command.
*
* @return start time (in milliseconds since epoch)
*/
public long getStartTime() {
return this.startTime;
}
/**
* Set the start time of this {@link Find} command.
*
* @param time start time (in milliseconds since epoch)
*/
public void setStartTime(long time) {
this.startTime = time;
}
/**
* Returns the minimum depth for applying expressions.
*
* @return min depth
*/
public int getMinDepth() {
return this.minDepth;
}
/**
* Sets the minimum depth for applying expressions.
*
* @param minDepth minimum depth
*/
public void setMinDepth(int minDepth) {
this.minDepth = minDepth;
}
/**
* Returns the maximum depth for applying expressions.
*
* @return maximum depth
*/
public int getMaxDepth() {
return this.maxDepth;
}
/**
* Sets the maximum depth for applying expressions.
*
* @param maxDepth maximum depth
*/
public void setMaxDepth(int maxDepth) {
this.maxDepth = maxDepth;
}
/**
* Set the command factory.
*
* @param factory {@link CommandFactory}
*/
public void setCommandFactory(CommandFactory factory) {
this.commandFactory = factory;
}
/**
* Return the command factory.
*
* @return {@link CommandFactory}
*/
public CommandFactory getCommandFactory() {
return this.commandFactory;
}
/**
* Set the {@link Configuration}
*
* @param configuration {@link Configuration}
*/
public void setConfiguration(Configuration configuration) {
this.configuration = configuration;
}
/**
* Return the {@link Configuration} return configuration {@link Configuration}
*/
public Configuration getConfiguration() {
return this.configuration;
}
}

100
hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/find/Name.java Normal file
View File

@ -0,0 +1,100 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import java.io.IOException;
import java.util.Deque;
import org.apache.hadoop.fs.GlobPattern;
import org.apache.hadoop.fs.shell.PathData;
/**
* Implements the -name expression for the
* {@link org.apache.hadoop.fs.shell.find.Find} command.
*/
final class Name extends BaseExpression {
/** Registers this expression with the specified factory. */
public static void registerExpression(ExpressionFactory factory)
throws IOException {
factory.addClass(Name.class, "-name");
factory.addClass(Iname.class, "-iname");
}
private static final String[] USAGE = { "-name pattern", "-iname pattern" };
private static final String[] HELP = {
"Evaluates as true if the basename of the file matches the",
"pattern using standard file system globbing.",
"If -iname is used then the match is case insensitive." };
private GlobPattern globPattern;
private boolean caseSensitive = true;
/** Creates a case sensitive name expression. */
public Name() {
this(true);
}
/**
* Construct a Name {@link Expression} with a specified case sensitivity.
*
* @param caseSensitive if true the comparisons are case sensitive.
*/
private Name(boolean caseSensitive) {
super();
setUsage(USAGE);
setHelp(HELP);
setCaseSensitive(caseSensitive);
}
private void setCaseSensitive(boolean caseSensitive) {
this.caseSensitive = caseSensitive;
}
@Override
public void addArguments(Deque<String> args) {
addArguments(args, 1);
}
@Override
public void prepare() throws IOException {
String argPattern = getArgument(1);
if (!caseSensitive) {
argPattern = argPattern.toLowerCase();
}
globPattern = new GlobPattern(argPattern);
}
@Override
public Result apply(PathData item, int depth) throws IOException {
String name = getPath(item).getName();
if (!caseSensitive) {
name = name.toLowerCase();
}
if (globPattern.matches(name)) {
return Result.PASS;
} else {
return Result.FAIL;
}
}
/** Case insensitive version of the -name expression. */
static class Iname extends FilterExpression {
public Iname() {
super(new Name(false));
}
}
}

76
hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/find/Print.java Normal file
View File

@ -0,0 +1,76 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import java.io.IOException;
import org.apache.hadoop.fs.shell.PathData;
/**
* Implements the -print expression for the
* {@link org.apache.hadoop.fs.shell.find.Find} command.
*/
final class Print extends BaseExpression {
/** Registers this expression with the specified factory. */
public static void registerExpression(ExpressionFactory factory)
throws IOException {
factory.addClass(Print.class, "-print");
factory.addClass(Print0.class, "-print0");
}
private static final String[] USAGE = { "-print", "-print0" };
private static final String[] HELP = {
"Always evaluates to true. Causes the current pathname to be",
"written to standard output followed by a newline. If the -print0",
"expression is used then an ASCII NULL character is appended rather",
"than a newline." };
private final String suffix;
public Print() {
this("\n");
}
/**
* Construct a Print {@link Expression} with the specified suffix.
*/
private Print(String suffix) {
super();
setUsage(USAGE);
setHelp(HELP);
this.suffix = suffix;
}
@Override
public Result apply(PathData item, int depth) throws IOException {
getOptions().getOut().print(item.toString() + suffix);
return Result.PASS;
}
@Override
public boolean isAction() {
return true;
}
/** Implements the -print0 expression. */
final static class Print0 extends FilterExpression {
public Print0() {
super(new Print("\0"));
}
}
}

88
hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/find/Result.java Normal file
View File

@ -0,0 +1,88 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
public final class Result {
/** Result indicating {@link Expression} processing should continue. */
public static final Result PASS = new Result(true, true);
/** Result indicating {@link Expression} processing should stop. */
public static final Result FAIL = new Result(false, true);
/**
* Result indicating {@link Expression} processing should not descend any more
* directories.
*/
public static final Result STOP = new Result(true, false);
private boolean descend;
private boolean success;
private Result(boolean success, boolean recurse) {
this.success = success;
this.descend = recurse;
}
/** Should further directories be descended. */
public boolean isDescend() {
return this.descend;
}
/** Should processing continue. */
public boolean isPass() {
return this.success;
}
/** Returns the combination of this and another result. */
public Result combine(Result other) {
return new Result(this.isPass() && other.isPass(), this.isDescend()
&& other.isDescend());
}
/** Negate this result. */
public Result negate() {
return new Result(!this.isPass(), this.isDescend());
}
@Override
public String toString() {
return "success=" + isPass() + "; recurse=" + isDescend();
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + (descend ? 1231 : 1237);
result = prime * result + (success ? 1231 : 1237);
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Result other = (Result) obj;
if (descend != other.descend)
return false;
if (success != other.success)
return false;
return true;
}
}

43
hadoop-common-project/hadoop-common/src/site/apt/FileSystemShell.apt.vm
View File

@ -232,6 +232,49 @@ expunge
Empty the Trash. Refer to the {{{../hadoop-hdfs/HdfsDesign.html}
HDFS Architecture Guide}} for more information on the Trash feature.
find
Usage: <<<hdfs dfs -find <path> ... <expression> ... >>>
Finds all files that match the specified expression and applies selected
actions to them. If no <path> is specified then defaults to the current
working directory. If no expression is specified then defaults to -print.
The following primary expressions are recognised:
* -name pattern \
-iname pattern
Evaluates as true if the basename of the file matches the pattern using
standard file system globbing. If -iname is used then the match is case
insensitive.
* -print \
-print0
Always evaluates to true. Causes the current pathname to be written to
standard output. If the -print0 expression is used then an ASCII NULL
character is appended.
The following operators are recognised:
* expression -a expression \
expression -and expression \
expression expression
Logical AND operator for joining two expressions. Returns true if both
child expressions return true. Implied by the juxtaposition of two
expressions and so does not need to be explicitly specified. The second
expression will not be applied if the first fails.
Example:
<<<hdfs dfs -find / -name test -print>>>
Exit Code:
Returns 0 on success and -1 on error.
get
Usage: <<<hdfs dfs -get [-ignorecrc] [-crc] <src> <localdst> >>>

86
hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/fs/shell/find/MockFileSystem.java Normal file
View File

@ -0,0 +1,86 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.when;
import java.io.IOException;
import java.net.URI;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.FilterFileSystem;
import org.apache.hadoop.fs.Path;
/**
* A mock {@link FileSystem} for use with the {@link Find} unit tests. Usage:
* FileSystem mockFs = MockFileSystem.setup(); Methods in the mockFs can then be
* mocked out by the test script. The {@link Configuration} can be accessed by
* mockFs.getConf(); The following methods are fixed within the class: -
* {@link FileSystem#initialize(URI,Configuration)} blank stub -
* {@link FileSystem#makeQualified(Path)} returns the passed in {@link Path} -
* {@link FileSystem#getWorkingDirectory} returns new Path("/") -
* {@link FileSystem#resolvePath(Path)} returns the passed in {@link Path}
*/
class MockFileSystem extends FilterFileSystem {
private static FileSystem mockFs = null;
/** Setup and return the underlying {@link FileSystem} mock */
static FileSystem setup() throws IOException {
if (mockFs == null) {
mockFs = mock(FileSystem.class);
}
reset(mockFs);
Configuration conf = new Configuration();
conf.set("fs.defaultFS", "mockfs:///");
conf.setClass("fs.mockfs.impl", MockFileSystem.class, FileSystem.class);
when(mockFs.getConf()).thenReturn(conf);
return mockFs;
}
private MockFileSystem() {
super(mockFs);
}
@Override
public void initialize(URI uri, Configuration conf) {
}
@Override
public Path makeQualified(Path path) {
return path;
}
@Override
public FileStatus[] globStatus(Path pathPattern) throws IOException {
return fs.globStatus(pathPattern);
}
@Override
public Path getWorkingDirectory() {
return new Path("/");
}
@Override
public Path resolvePath(final Path p) throws IOException {
return p;
}
}

263
hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/fs/shell/find/TestAnd.java Normal file
View File

@ -0,0 +1,263 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import java.io.IOException;
import java.util.Deque;
import java.util.LinkedList;
import org.apache.hadoop.fs.shell.PathData;
import org.junit.Test;
public class TestAnd {
// test all expressions passing
@Test(timeout = 1000)
public void testPass() throws IOException {
And and = new And();
PathData pathData = mock(PathData.class);
Expression first = mock(Expression.class);
when(first.apply(pathData, -1)).thenReturn(Result.PASS);
Expression second = mock(Expression.class);
when(second.apply(pathData, -1)).thenReturn(Result.PASS);
Deque<Expression> children = new LinkedList<Expression>();
children.add(second);
children.add(first);
and.addChildren(children);
assertEquals(Result.PASS, and.apply(pathData, -1));
verify(first).apply(pathData, -1);
verify(second).apply(pathData, -1);
verifyNoMoreInteractions(first);
verifyNoMoreInteractions(second);
}
// test the first expression failing
@Test(timeout = 1000)
public void testFailFirst() throws IOException {
And and = new And();
PathData pathData = mock(PathData.class);
Expression first = mock(Expression.class);
when(first.apply(pathData, -1)).thenReturn(Result.FAIL);
Expression second = mock(Expression.class);
when(second.apply(pathData, -1)).thenReturn(Result.PASS);
Deque<Expression> children = new LinkedList<Expression>();
children.add(second);
children.add(first);
and.addChildren(children);
assertEquals(Result.FAIL, and.apply(pathData, -1));
verify(first).apply(pathData, -1);
verifyNoMoreInteractions(first);
verifyNoMoreInteractions(second);
}
// test the second expression failing
@Test(timeout = 1000)
public void testFailSecond() throws IOException {
And and = new And();
PathData pathData = mock(PathData.class);
Expression first = mock(Expression.class);
when(first.apply(pathData, -1)).thenReturn(Result.PASS);
Expression second = mock(Expression.class);
when(second.apply(pathData, -1)).thenReturn(Result.FAIL);
Deque<Expression> children = new LinkedList<Expression>();
children.add(second);
children.add(first);
and.addChildren(children);
assertEquals(Result.FAIL, and.apply(pathData, -1));
verify(first).apply(pathData, -1);
verify(second).apply(pathData, -1);
verifyNoMoreInteractions(first);
verifyNoMoreInteractions(second);
}
// test both expressions failing
@Test(timeout = 1000)
public void testFailBoth() throws IOException {
And and = new And();
PathData pathData = mock(PathData.class);
Expression first = mock(Expression.class);
when(first.apply(pathData, -1)).thenReturn(Result.FAIL);
Expression second = mock(Expression.class);
when(second.apply(pathData, -1)).thenReturn(Result.FAIL);
Deque<Expression> children = new LinkedList<Expression>();
children.add(second);
children.add(first);
and.addChildren(children);
assertEquals(Result.FAIL, and.apply(pathData, -1));
verify(first).apply(pathData, -1);
verifyNoMoreInteractions(first);
verifyNoMoreInteractions(second);
}
// test the first expression stopping
@Test(timeout = 1000)
public void testStopFirst() throws IOException {
And and = new And();
PathData pathData = mock(PathData.class);
Expression first = mock(Expression.class);
when(first.apply(pathData, -1)).thenReturn(Result.STOP);
Expression second = mock(Expression.class);
when(second.apply(pathData, -1)).thenReturn(Result.PASS);
Deque<Expression> children = new LinkedList<Expression>();
children.add(second);
children.add(first);
and.addChildren(children);
assertEquals(Result.STOP, and.apply(pathData, -1));
verify(first).apply(pathData, -1);
verify(second).apply(pathData, -1);
verifyNoMoreInteractions(first);
verifyNoMoreInteractions(second);
}
// test the second expression stopping
@Test(timeout = 1000)
public void testStopSecond() throws IOException {
And and = new And();
PathData pathData = mock(PathData.class);
Expression first = mock(Expression.class);
when(first.apply(pathData, -1)).thenReturn(Result.PASS);
Expression second = mock(Expression.class);
when(second.apply(pathData, -1)).thenReturn(Result.STOP);
Deque<Expression> children = new LinkedList<Expression>();
children.add(second);
children.add(first);
and.addChildren(children);
assertEquals(Result.STOP, and.apply(pathData, -1));
verify(first).apply(pathData, -1);
verify(second).apply(pathData, -1);
verifyNoMoreInteractions(first);
verifyNoMoreInteractions(second);
}
// test first expression stopping and second failing
@Test(timeout = 1000)
public void testStopFail() throws IOException {
And and = new And();
PathData pathData = mock(PathData.class);
Expression first = mock(Expression.class);
when(first.apply(pathData, -1)).thenReturn(Result.STOP);
Expression second = mock(Expression.class);
when(second.apply(pathData, -1)).thenReturn(Result.FAIL);
Deque<Expression> children = new LinkedList<Expression>();
children.add(second);
children.add(first);
and.addChildren(children);
assertEquals(Result.STOP.combine(Result.FAIL), and.apply(pathData, -1));
verify(first).apply(pathData, -1);
verify(second).apply(pathData, -1);
verifyNoMoreInteractions(first);
verifyNoMoreInteractions(second);
}
// test setOptions is called on child
@Test(timeout = 1000)
public void testSetOptions() throws IOException {
And and = new And();
Expression first = mock(Expression.class);
Expression second = mock(Expression.class);
Deque<Expression> children = new LinkedList<Expression>();
children.add(second);
children.add(first);
and.addChildren(children);
FindOptions options = mock(FindOptions.class);
and.setOptions(options);
verify(first).setOptions(options);
verify(second).setOptions(options);
verifyNoMoreInteractions(first);
verifyNoMoreInteractions(second);
}
// test prepare is called on child
@Test(timeout = 1000)
public void testPrepare() throws IOException {
And and = new And();
Expression first = mock(Expression.class);
Expression second = mock(Expression.class);
Deque<Expression> children = new LinkedList<Expression>();
children.add(second);
children.add(first);
and.addChildren(children);
and.prepare();
verify(first).prepare();
verify(second).prepare();
verifyNoMoreInteractions(first);
verifyNoMoreInteractions(second);
}
// test finish is called on child
@Test(timeout = 1000)
public void testFinish() throws IOException {
And and = new And();
Expression first = mock(Expression.class);
Expression second = mock(Expression.class);
Deque<Expression> children = new LinkedList<Expression>();
children.add(second);
children.add(first);
and.addChildren(children);
and.finish();
verify(first).finish();
verify(second).finish();
verifyNoMoreInteractions(first);
verifyNoMoreInteractions(second);
}
}

145
hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/fs/shell/find/TestFilterExpression.java Normal file
View File

@ -0,0 +1,145 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import java.io.IOException;
import java.util.Deque;
import org.apache.hadoop.fs.shell.PathData;
import org.junit.Before;
import org.junit.Test;
public class TestFilterExpression {
private Expression expr;
private FilterExpression test;
@Before
public void setup() {
expr = mock(Expression.class);
test = new FilterExpression(expr) {
};
}
// test that the child expression is correctly set
@Test(timeout = 1000)
public void expression() throws IOException {
assertEquals(expr, test.expression);
}
// test that setOptions method is called
@Test(timeout = 1000)
public void setOptions() throws IOException {
FindOptions options = mock(FindOptions.class);
test.setOptions(options);
verify(expr).setOptions(options);
verifyNoMoreInteractions(expr);
}
// test the apply method is called and the result returned
@Test(timeout = 1000)
public void apply() throws IOException {
PathData item = mock(PathData.class);
when(expr.apply(item, -1)).thenReturn(Result.PASS).thenReturn(Result.FAIL);
assertEquals(Result.PASS, test.apply(item, -1));
assertEquals(Result.FAIL, test.apply(item, -1));
verify(expr, times(2)).apply(item, -1);
verifyNoMoreInteractions(expr);
}
// test that the finish method is called
@Test(timeout = 1000)
public void finish() throws IOException {
test.finish();
verify(expr).finish();
verifyNoMoreInteractions(expr);
}
// test that the getUsage method is called
@Test(timeout = 1000)
public void getUsage() {
String[] usage = new String[] { "Usage 1", "Usage 2", "Usage 3" };
when(expr.getUsage()).thenReturn(usage);
assertArrayEquals(usage, test.getUsage());
verify(expr).getUsage();
verifyNoMoreInteractions(expr);
}
// test that the getHelp method is called
@Test(timeout = 1000)
public void getHelp() {
String[] help = new String[] { "Help 1", "Help 2", "Help 3" };
when(expr.getHelp()).thenReturn(help);
assertArrayEquals(help, test.getHelp());
verify(expr).getHelp();
verifyNoMoreInteractions(expr);
}
// test that the isAction method is called
@Test(timeout = 1000)
public void isAction() {
when(expr.isAction()).thenReturn(true).thenReturn(false);
assertTrue(test.isAction());
assertFalse(test.isAction());
verify(expr, times(2)).isAction();
verifyNoMoreInteractions(expr);
}
// test that the isOperator method is called
@Test(timeout = 1000)
public void isOperator() {
when(expr.isAction()).thenReturn(true).thenReturn(false);
assertTrue(test.isAction());
assertFalse(test.isAction());
verify(expr, times(2)).isAction();
verifyNoMoreInteractions(expr);
}
// test that the getPrecedence method is called
@Test(timeout = 1000)
public void getPrecedence() {
int precedence = 12345;
when(expr.getPrecedence()).thenReturn(precedence);
assertEquals(precedence, test.getPrecedence());
verify(expr).getPrecedence();
verifyNoMoreInteractions(expr);
}
// test that the addChildren method is called
@Test(timeout = 1000)
public void addChildren() {
@SuppressWarnings("unchecked")
Deque<Expression> expressions = mock(Deque.class);
test.addChildren(expressions);
verify(expr).addChildren(expressions);
verifyNoMoreInteractions(expr);
}
// test that the addArguments method is called
@Test(timeout = 1000)
public void addArguments() {
@SuppressWarnings("unchecked")
Deque<String> args = mock(Deque.class);
test.addArguments(args);
verify(expr).addArguments(args);
verifyNoMoreInteractions(expr);
}
}

900
hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/fs/shell/find/TestFind.java Normal file
View File

@ -0,0 +1,900 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import static org.mockito.Matchers.*;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.shell.PathData;
import org.apache.hadoop.fs.shell.find.BaseExpression;
import org.apache.hadoop.fs.shell.find.Expression;
import org.apache.hadoop.fs.shell.find.Find;
import org.apache.hadoop.fs.shell.find.FindOptions;
import org.apache.hadoop.fs.shell.find.Result;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
public class TestFind {
private static FileSystem mockFs;
private static Configuration conf;
@Before
public void setup() throws IOException {
mockFs = MockFileSystem.setup();
conf = mockFs.getConf();
}
// check follow link option is recognized
@Test(timeout = 1000)
public void processOptionsFollowLink() throws IOException {
Find find = new Find();
String args = "-L path";
find.processOptions(getArgs(args));
assertTrue(find.getOptions().isFollowLink());
assertFalse(find.getOptions().isFollowArgLink());
}
// check follow arg link option is recognized
@Test(timeout = 1000)
public void processOptionsFollowArgLink() throws IOException {
Find find = new Find();
String args = "-H path";
find.processOptions(getArgs(args));
assertFalse(find.getOptions().isFollowLink());
assertTrue(find.getOptions().isFollowArgLink());
}
// check follow arg link option is recognized
@Test(timeout = 1000)
public void processOptionsFollowLinkFollowArgLink() throws IOException {
Find find = new Find();
String args = "-L -H path";
find.processOptions(getArgs(args));
assertTrue(find.getOptions().isFollowLink());
// follow link option takes precedence over follow arg link
assertFalse(find.getOptions().isFollowArgLink());
}
// check options and expressions are stripped from args leaving paths
@Test(timeout = 1000)
public void processOptionsExpression() throws IOException {
Find find = new Find();
find.setConf(conf);
String paths = "path1 path2 path3";
String args = "-L -H " + paths + " -print -name test";
LinkedList<String> argsList = getArgs(args);
find.processOptions(argsList);
LinkedList<String> pathList = getArgs(paths);
assertEquals(pathList, argsList);
}
// check print is used as the default expression
@Test(timeout = 1000)
public void processOptionsNoExpression() throws IOException {
Find find = new Find();
find.setConf(conf);
String args = "path";
String expected = "Print(;)";
find.processOptions(getArgs(args));
Expression expression = find.getRootExpression();
assertEquals(expected, expression.toString());
}
// check unknown options are rejected
@Test(timeout = 1000)
public void processOptionsUnknown() throws IOException {
Find find = new Find();
find.setConf(conf);
String args = "path -unknown";
try {
find.processOptions(getArgs(args));
fail("Unknown expression not caught");
} catch (IOException e) {
}
}
// check unknown options are rejected when mixed with known options
@Test(timeout = 1000)
public void processOptionsKnownUnknown() throws IOException {
Find find = new Find();
find.setConf(conf);
String args = "path -print -unknown -print";
try {
find.processOptions(getArgs(args));
fail("Unknown expression not caught");
} catch (IOException e) {
}
}
// check no path defaults to current working directory
@Test(timeout = 1000)
public void processOptionsNoPath() throws IOException {
Find find = new Find();
find.setConf(conf);
String args = "-print";
LinkedList<String> argsList = getArgs(args);
find.processOptions(argsList);
assertEquals(Collections.singletonList(Path.CUR_DIR), argsList);
}
// check -name is handled correctly
@Test(timeout = 1000)
public void processOptionsName() throws IOException {
Find find = new Find();
find.setConf(conf);
String args = "path -name namemask";
String expected = "And(;Name(namemask;),Print(;))";
find.processOptions(getArgs(args));
Expression expression = find.getRootExpression();
assertEquals(expected, expression.toString());
}
// check -iname is handled correctly
@Test(timeout = 1000)
public void processOptionsIname() throws IOException {
Find find = new Find();
find.setConf(conf);
String args = "path -iname namemask";
String expected = "And(;Iname-Name(namemask;),Print(;))";
find.processOptions(getArgs(args));
Expression expression = find.getRootExpression();
assertEquals(expected, expression.toString());
}
// check -print is handled correctly
@Test(timeout = 1000)
public void processOptionsPrint() throws IOException {
Find find = new Find();
find.setConf(conf);
String args = "path -print";
String expected = "Print(;)";
find.processOptions(getArgs(args));
Expression expression = find.getRootExpression();
assertEquals(expected, expression.toString());
}
// check -print0 is handled correctly
@Test(timeout = 1000)
public void processOptionsPrint0() throws IOException {
Find find = new Find();
find.setConf(conf);
String args = "path -print0";
String expected = "Print0-Print(;)";
find.processOptions(getArgs(args));
Expression expression = find.getRootExpression();
assertEquals(expected, expression.toString());
}
// check an implicit and is handled correctly
@Test(timeout = 1000)
public void processOptionsNoop() throws IOException {
Find find = new Find();
find.setConf(conf);
String args = "path -name one -name two -print";
String expected = "And(;And(;Name(one;),Name(two;)),Print(;))";
find.processOptions(getArgs(args));
Expression expression = find.getRootExpression();
assertEquals(expected, expression.toString());
}
// check -a is handled correctly
@Test(timeout = 1000)
public void processOptionsA() throws IOException {
Find find = new Find();
find.setConf(conf);
String args = "path -name one -a -name two -a -print";
String expected = "And(;And(;Name(one;),Name(two;)),Print(;))";
find.processOptions(getArgs(args));
Expression expression = find.getRootExpression();
assertEquals(expected, expression.toString());
}
// check -and is handled correctly
@Test(timeout = 1000)
public void processOptionsAnd() throws IOException {
Find find = new Find();
find.setConf(conf);
String args = "path -name one -and -name two -and -print";
String expected = "And(;And(;Name(one;),Name(two;)),Print(;))";
find.processOptions(getArgs(args));
Expression expression = find.getRootExpression();
assertEquals(expected, expression.toString());
}
// check expressions are called in the correct order
@Test(timeout = 1000)
public void processArguments() throws IOException {
LinkedList<PathData> items = createDirectories();
Find find = new Find();
find.setConf(conf);
PrintStream out = mock(PrintStream.class);
find.getOptions().setOut(out);
PrintStream err = mock(PrintStream.class);
find.getOptions().setErr(err);
Expression expr = mock(Expression.class);
when(expr.apply((PathData) any(), anyInt())).thenReturn(Result.PASS);
FileStatusChecker fsCheck = mock(FileStatusChecker.class);
Expression test = new TestExpression(expr, fsCheck);
find.setRootExpression(test);
find.processArguments(items);
InOrder inOrder = inOrder(expr);
inOrder.verify(expr).setOptions(find.getOptions());
inOrder.verify(expr).prepare();
inOrder.verify(expr).apply(item1, 0);
inOrder.verify(expr).apply(item1a, 1);
inOrder.verify(expr).apply(item1aa, 2);
inOrder.verify(expr).apply(item1b, 1);
inOrder.verify(expr).apply(item2, 0);
inOrder.verify(expr).apply(item3, 0);
inOrder.verify(expr).apply(item4, 0);
inOrder.verify(expr).apply(item5, 0);
inOrder.verify(expr).apply(item5a, 1);
inOrder.verify(expr).apply(item5b, 1);
inOrder.verify(expr).apply(item5c, 1);
inOrder.verify(expr).apply(item5ca, 2);
inOrder.verify(expr).apply(item5d, 1);
inOrder.verify(expr).apply(item5e, 1);
inOrder.verify(expr).finish();
verifyNoMoreInteractions(expr);
InOrder inOrderFsCheck = inOrder(fsCheck);
inOrderFsCheck.verify(fsCheck).check(item1.stat);
inOrderFsCheck.verify(fsCheck).check(item1a.stat);
inOrderFsCheck.verify(fsCheck).check(item1aa.stat);
inOrderFsCheck.verify(fsCheck).check(item1b.stat);
inOrderFsCheck.verify(fsCheck).check(item2.stat);
inOrderFsCheck.verify(fsCheck).check(item3.stat);
inOrderFsCheck.verify(fsCheck).check(item4.stat);
inOrderFsCheck.verify(fsCheck).check(item5.stat);
inOrderFsCheck.verify(fsCheck).check(item5a.stat);
inOrderFsCheck.verify(fsCheck).check(item5b.stat);
inOrderFsCheck.verify(fsCheck).check(item5c.stat);
inOrderFsCheck.verify(fsCheck).check(item5ca.stat);
inOrderFsCheck.verify(fsCheck).check(item5d.stat);
inOrderFsCheck.verify(fsCheck).check(item5e.stat);
verifyNoMoreInteractions(fsCheck);
verifyNoMoreInteractions(out);
verifyNoMoreInteractions(err);
}
// check that directories are descended correctly when -depth is specified
@Test(timeout = 1000)
public void processArgumentsDepthFirst() throws IOException {
LinkedList<PathData> items = createDirectories();
Find find = new Find();
find.getOptions().setDepthFirst(true);
find.setConf(conf);
PrintStream out = mock(PrintStream.class);
find.getOptions().setOut(out);
PrintStream err = mock(PrintStream.class);
find.getOptions().setErr(err);
Expression expr = mock(Expression.class);
when(expr.apply((PathData) any(), anyInt())).thenReturn(Result.PASS);
FileStatusChecker fsCheck = mock(FileStatusChecker.class);
Expression test = new TestExpression(expr, fsCheck);
find.setRootExpression(test);
find.processArguments(items);
InOrder inOrder = inOrder(expr);
inOrder.verify(expr).setOptions(find.getOptions());
inOrder.verify(expr).prepare();
inOrder.verify(expr).apply(item1aa, 2);
inOrder.verify(expr).apply(item1a, 1);
inOrder.verify(expr).apply(item1b, 1);
inOrder.verify(expr).apply(item1, 0);
inOrder.verify(expr).apply(item2, 0);
inOrder.verify(expr).apply(item3, 0);
inOrder.verify(expr).apply(item4, 0);
inOrder.verify(expr).apply(item5a, 1);
inOrder.verify(expr).apply(item5b, 1);
inOrder.verify(expr).apply(item5ca, 2);
inOrder.verify(expr).apply(item5c, 1);
inOrder.verify(expr).apply(item5d, 1);
inOrder.verify(expr).apply(item5e, 1);
inOrder.verify(expr).apply(item5, 0);
inOrder.verify(expr).finish();
verifyNoMoreInteractions(expr);
InOrder inOrderFsCheck = inOrder(fsCheck);
inOrderFsCheck.verify(fsCheck).check(item1aa.stat);
inOrderFsCheck.verify(fsCheck).check(item1a.stat);
inOrderFsCheck.verify(fsCheck).check(item1b.stat);
inOrderFsCheck.verify(fsCheck).check(item1.stat);
inOrderFsCheck.verify(fsCheck).check(item2.stat);
inOrderFsCheck.verify(fsCheck).check(item3.stat);
inOrderFsCheck.verify(fsCheck).check(item4.stat);
inOrderFsCheck.verify(fsCheck).check(item5a.stat);
inOrderFsCheck.verify(fsCheck).check(item5b.stat);
inOrderFsCheck.verify(fsCheck).check(item5ca.stat);
inOrderFsCheck.verify(fsCheck).check(item5c.stat);
inOrderFsCheck.verify(fsCheck).check(item5d.stat);
inOrderFsCheck.verify(fsCheck).check(item5e.stat);
inOrderFsCheck.verify(fsCheck).check(item5.stat);
verifyNoMoreInteractions(fsCheck);
verifyNoMoreInteractions(out);
verifyNoMoreInteractions(err);
}
// check symlinks given as path arguments are processed correctly with the
// follow arg option set
@Test(timeout = 1000)
public void processArgumentsOptionFollowArg() throws IOException {
LinkedList<PathData> items = createDirectories();
Find find = new Find();
find.getOptions().setFollowArgLink(true);
find.setConf(conf);
PrintStream out = mock(PrintStream.class);
find.getOptions().setOut(out);
PrintStream err = mock(PrintStream.class);
find.getOptions().setErr(err);
Expression expr = mock(Expression.class);
when(expr.apply((PathData) any(), anyInt())).thenReturn(Result.PASS);
FileStatusChecker fsCheck = mock(FileStatusChecker.class);
Expression test = new TestExpression(expr, fsCheck);
find.setRootExpression(test);
find.processArguments(items);
InOrder inOrder = inOrder(expr);
inOrder.verify(expr).setOptions(find.getOptions());
inOrder.verify(expr).prepare();
inOrder.verify(expr).apply(item1, 0);
inOrder.verify(expr).apply(item1a, 1);
inOrder.verify(expr).apply(item1aa, 2);
inOrder.verify(expr).apply(item1b, 1);
inOrder.verify(expr).apply(item2, 0);
inOrder.verify(expr).apply(item3, 0);
inOrder.verify(expr).apply(item4, 0);
inOrder.verify(expr).apply(item5, 0);
inOrder.verify(expr).apply(item5a, 1);
inOrder.verify(expr).apply(item5b, 1);
inOrder.verify(expr).apply(item5c, 1);
inOrder.verify(expr).apply(item5ca, 2);
inOrder.verify(expr).apply(item5d, 1);
inOrder.verify(expr).apply(item5e, 1);
inOrder.verify(expr).finish();
verifyNoMoreInteractions(expr);
InOrder inOrderFsCheck = inOrder(fsCheck);
inOrderFsCheck.verify(fsCheck).check(item1.stat);
inOrderFsCheck.verify(fsCheck).check(item1a.stat);
inOrderFsCheck.verify(fsCheck).check(item1aa.stat);
inOrderFsCheck.verify(fsCheck).check(item1b.stat);
inOrderFsCheck.verify(fsCheck).check(item2.stat);
inOrderFsCheck.verify(fsCheck, times(2)).check(item3.stat);
inOrderFsCheck.verify(fsCheck).check(item5.stat);
inOrderFsCheck.verify(fsCheck).check(item5a.stat);
inOrderFsCheck.verify(fsCheck).check(item5b.stat);
inOrderFsCheck.verify(fsCheck).check(item5c.stat);
inOrderFsCheck.verify(fsCheck).check(item5ca.stat);
inOrderFsCheck.verify(fsCheck).check(item5d.stat);
inOrderFsCheck.verify(fsCheck).check(item5e.stat);
verifyNoMoreInteractions(fsCheck);
verifyNoMoreInteractions(out);
verifyNoMoreInteractions(err);
}
// check symlinks given as path arguments are processed correctly with the
// follow option
@Test(timeout = 1000)
public void processArgumentsOptionFollow() throws IOException {
LinkedList<PathData> items = createDirectories();
Find find = new Find();
find.getOptions().setFollowLink(true);
find.setConf(conf);
PrintStream out = mock(PrintStream.class);
find.getOptions().setOut(out);
PrintStream err = mock(PrintStream.class);
find.getOptions().setErr(err);
Expression expr = mock(Expression.class);
when(expr.apply((PathData) any(), anyInt())).thenReturn(Result.PASS);
FileStatusChecker fsCheck = mock(FileStatusChecker.class);
Expression test = new TestExpression(expr, fsCheck);
find.setRootExpression(test);
find.processArguments(items);
InOrder inOrder = inOrder(expr);
inOrder.verify(expr).setOptions(find.getOptions());
inOrder.verify(expr).prepare();
inOrder.verify(expr).apply(item1, 0);
inOrder.verify(expr).apply(item1a, 1);
inOrder.verify(expr).apply(item1aa, 2);
inOrder.verify(expr).apply(item1b, 1);
inOrder.verify(expr).apply(item2, 0);
inOrder.verify(expr).apply(item3, 0);
inOrder.verify(expr).apply(item4, 0);
inOrder.verify(expr).apply(item5, 0);
inOrder.verify(expr).apply(item5a, 1);
inOrder.verify(expr).apply(item5b, 1); // triggers infinite loop message
inOrder.verify(expr).apply(item5c, 1);
inOrder.verify(expr).apply(item5ca, 2);
inOrder.verify(expr).apply(item5d, 1);
inOrder.verify(expr).apply(item5ca, 2); // following item5d symlink
inOrder.verify(expr).apply(item5e, 1);
inOrder.verify(expr).finish();
verifyNoMoreInteractions(expr);
InOrder inOrderFsCheck = inOrder(fsCheck);
inOrderFsCheck.verify(fsCheck).check(item1.stat);
inOrderFsCheck.verify(fsCheck).check(item1a.stat);
inOrderFsCheck.verify(fsCheck).check(item1aa.stat);
inOrderFsCheck.verify(fsCheck).check(item1b.stat);
inOrderFsCheck.verify(fsCheck).check(item2.stat);
inOrderFsCheck.verify(fsCheck, times(2)).check(item3.stat);
inOrderFsCheck.verify(fsCheck).check(item5.stat);
inOrderFsCheck.verify(fsCheck).check(item1b.stat);
inOrderFsCheck.verify(fsCheck).check(item5.stat);
inOrderFsCheck.verify(fsCheck).check(item5c.stat);
inOrderFsCheck.verify(fsCheck).check(item5ca.stat);
inOrderFsCheck.verify(fsCheck).check(item5c.stat);
inOrderFsCheck.verify(fsCheck, times(2)).check(item5ca.stat);
verifyNoMoreInteractions(fsCheck);
verifyNoMoreInteractions(out);
verify(err).println(
"Infinite loop ignored: " + item5b.toString() + " -> "
+ item5.toString());
verifyNoMoreInteractions(err);
}
// check minimum depth is handledfollowLink
@Test(timeout = 1000)
public void processArgumentsMinDepth() throws IOException {
LinkedList<PathData> items = createDirectories();
Find find = new Find();
find.getOptions().setMinDepth(1);
find.setConf(conf);
PrintStream out = mock(PrintStream.class);
find.getOptions().setOut(out);
PrintStream err = mock(PrintStream.class);
find.getOptions().setErr(err);
Expression expr = mock(Expression.class);
when(expr.apply((PathData) any(), anyInt())).thenReturn(Result.PASS);
FileStatusChecker fsCheck = mock(FileStatusChecker.class);
Expression test = new TestExpression(expr, fsCheck);
find.setRootExpression(test);
find.processArguments(items);
InOrder inOrder = inOrder(expr);
inOrder.verify(expr).setOptions(find.getOptions());
inOrder.verify(expr).prepare();
inOrder.verify(expr).apply(item1a, 1);
inOrder.verify(expr).apply(item1aa, 2);
inOrder.verify(expr).apply(item1b, 1);
inOrder.verify(expr).apply(item5a, 1);
inOrder.verify(expr).apply(item5b, 1);
inOrder.verify(expr).apply(item5c, 1);
inOrder.verify(expr).apply(item5ca, 2);
inOrder.verify(expr).apply(item5d, 1);
inOrder.verify(expr).apply(item5e, 1);
inOrder.verify(expr).finish();
verifyNoMoreInteractions(expr);
InOrder inOrderFsCheck = inOrder(fsCheck);
inOrderFsCheck.verify(fsCheck).check(item1a.stat);
inOrderFsCheck.verify(fsCheck).check(item1aa.stat);
inOrderFsCheck.verify(fsCheck).check(item1b.stat);
inOrderFsCheck.verify(fsCheck).check(item5a.stat);
inOrderFsCheck.verify(fsCheck).check(item5b.stat);
inOrderFsCheck.verify(fsCheck).check(item5c.stat);
inOrderFsCheck.verify(fsCheck).check(item5ca.stat);
inOrderFsCheck.verify(fsCheck).check(item5d.stat);
inOrderFsCheck.verify(fsCheck).check(item5e.stat);
verifyNoMoreInteractions(fsCheck);
verifyNoMoreInteractions(out);
verifyNoMoreInteractions(err);
}
// check maximum depth is handled
@Test(timeout = 1000)
public void processArgumentsMaxDepth() throws IOException {
LinkedList<PathData> items = createDirectories();
Find find = new Find();
find.getOptions().setMaxDepth(1);
find.setConf(conf);
PrintStream out = mock(PrintStream.class);
find.getOptions().setOut(out);
PrintStream err = mock(PrintStream.class);
find.getOptions().setErr(err);
Expression expr = mock(Expression.class);
when(expr.apply((PathData) any(), anyInt())).thenReturn(Result.PASS);
FileStatusChecker fsCheck = mock(FileStatusChecker.class);
Expression test = new TestExpression(expr, fsCheck);
find.setRootExpression(test);
find.processArguments(items);
InOrder inOrder = inOrder(expr);
inOrder.verify(expr).setOptions(find.getOptions());
inOrder.verify(expr).prepare();
inOrder.verify(expr).apply(item1, 0);
inOrder.verify(expr).apply(item1a, 1);
inOrder.verify(expr).apply(item1b, 1);
inOrder.verify(expr).apply(item2, 0);
inOrder.verify(expr).apply(item3, 0);
inOrder.verify(expr).apply(item4, 0);
inOrder.verify(expr).apply(item5, 0);
inOrder.verify(expr).apply(item5a, 1);
inOrder.verify(expr).apply(item5b, 1);
inOrder.verify(expr).apply(item5c, 1);
inOrder.verify(expr).apply(item5d, 1);
inOrder.verify(expr).apply(item5e, 1);
inOrder.verify(expr).finish();
verifyNoMoreInteractions(expr);
InOrder inOrderFsCheck = inOrder(fsCheck);
inOrderFsCheck.verify(fsCheck).check(item1.stat);
inOrderFsCheck.verify(fsCheck).check(item1a.stat);
inOrderFsCheck.verify(fsCheck).check(item1b.stat);
inOrderFsCheck.verify(fsCheck).check(item2.stat);
inOrderFsCheck.verify(fsCheck).check(item3.stat);
inOrderFsCheck.verify(fsCheck).check(item4.stat);
inOrderFsCheck.verify(fsCheck).check(item5.stat);
inOrderFsCheck.verify(fsCheck).check(item5a.stat);
inOrderFsCheck.verify(fsCheck).check(item5b.stat);
inOrderFsCheck.verify(fsCheck).check(item5c.stat);
inOrderFsCheck.verify(fsCheck).check(item5d.stat);
inOrderFsCheck.verify(fsCheck).check(item5e.stat);
verifyNoMoreInteractions(fsCheck);
verifyNoMoreInteractions(out);
verifyNoMoreInteractions(err);
}
// check min depth is handled when -depth is specified
@Test(timeout = 1000)
public void processArgumentsDepthFirstMinDepth() throws IOException {
LinkedList<PathData> items = createDirectories();
Find find = new Find();
find.getOptions().setDepthFirst(true);
find.getOptions().setMinDepth(1);
find.setConf(conf);
PrintStream out = mock(PrintStream.class);
find.getOptions().setOut(out);
PrintStream err = mock(PrintStream.class);
find.getOptions().setErr(err);
Expression expr = mock(Expression.class);
when(expr.apply((PathData) any(), anyInt())).thenReturn(Result.PASS);
FileStatusChecker fsCheck = mock(FileStatusChecker.class);
Expression test = new TestExpression(expr, fsCheck);
find.setRootExpression(test);
find.processArguments(items);
InOrder inOrder = inOrder(expr);
inOrder.verify(expr).setOptions(find.getOptions());
inOrder.verify(expr).prepare();
inOrder.verify(expr).apply(item1aa, 2);
inOrder.verify(expr).apply(item1a, 1);
inOrder.verify(expr).apply(item1b, 1);
inOrder.verify(expr).apply(item5a, 1);
inOrder.verify(expr).apply(item5b, 1);
inOrder.verify(expr).apply(item5ca, 2);
inOrder.verify(expr).apply(item5c, 1);
inOrder.verify(expr).apply(item5d, 1);
inOrder.verify(expr).apply(item5e, 1);
inOrder.verify(expr).finish();
verifyNoMoreInteractions(expr);
InOrder inOrderFsCheck = inOrder(fsCheck);
inOrderFsCheck.verify(fsCheck).check(item1aa.stat);
inOrderFsCheck.verify(fsCheck).check(item1a.stat);
inOrderFsCheck.verify(fsCheck).check(item1b.stat);
inOrderFsCheck.verify(fsCheck).check(item5a.stat);
inOrderFsCheck.verify(fsCheck).check(item5b.stat);
inOrderFsCheck.verify(fsCheck).check(item5ca.stat);
inOrderFsCheck.verify(fsCheck).check(item5c.stat);
inOrderFsCheck.verify(fsCheck).check(item5d.stat);
inOrderFsCheck.verify(fsCheck).check(item5e.stat);
verifyNoMoreInteractions(fsCheck);
verifyNoMoreInteractions(out);
verifyNoMoreInteractions(err);
}
// check max depth is handled when -depth is specified
@Test(timeout = 1000)
public void processArgumentsDepthFirstMaxDepth() throws IOException {
LinkedList<PathData> items = createDirectories();
Find find = new Find();
find.getOptions().setDepthFirst(true);
find.getOptions().setMaxDepth(1);
find.setConf(conf);
PrintStream out = mock(PrintStream.class);
find.getOptions().setOut(out);
PrintStream err = mock(PrintStream.class);
find.getOptions().setErr(err);
Expression expr = mock(Expression.class);
when(expr.apply((PathData) any(), anyInt())).thenReturn(Result.PASS);
FileStatusChecker fsCheck = mock(FileStatusChecker.class);
Expression test = new TestExpression(expr, fsCheck);
find.setRootExpression(test);
find.processArguments(items);
InOrder inOrder = inOrder(expr);
inOrder.verify(expr).setOptions(find.getOptions());
inOrder.verify(expr).prepare();
inOrder.verify(expr).apply(item1a, 1);
inOrder.verify(expr).apply(item1b, 1);
inOrder.verify(expr).apply(item1, 0);
inOrder.verify(expr).apply(item2, 0);
inOrder.verify(expr).apply(item3, 0);
inOrder.verify(expr).apply(item4, 0);
inOrder.verify(expr).apply(item5a, 1);
inOrder.verify(expr).apply(item5b, 1);
inOrder.verify(expr).apply(item5c, 1);
inOrder.verify(expr).apply(item5d, 1);
inOrder.verify(expr).apply(item5e, 1);
inOrder.verify(expr).apply(item5, 0);
inOrder.verify(expr).finish();
verifyNoMoreInteractions(expr);
InOrder inOrderFsCheck = inOrder(fsCheck);
inOrderFsCheck.verify(fsCheck).check(item1a.stat);
inOrderFsCheck.verify(fsCheck).check(item1b.stat);
inOrderFsCheck.verify(fsCheck).check(item1.stat);
inOrderFsCheck.verify(fsCheck).check(item2.stat);
inOrderFsCheck.verify(fsCheck).check(item3.stat);
inOrderFsCheck.verify(fsCheck).check(item4.stat);
inOrderFsCheck.verify(fsCheck).check(item5a.stat);
inOrderFsCheck.verify(fsCheck).check(item5b.stat);
inOrderFsCheck.verify(fsCheck).check(item5c.stat);
inOrderFsCheck.verify(fsCheck).check(item5d.stat);
inOrderFsCheck.verify(fsCheck).check(item5e.stat);
inOrderFsCheck.verify(fsCheck).check(item5.stat);
verifyNoMoreInteractions(fsCheck);
verifyNoMoreInteractions(out);
verifyNoMoreInteractions(err);
}
// check expressions are called in the correct order
@Test(timeout = 1000)
public void processArgumentsNoDescend() throws IOException {
LinkedList<PathData> items = createDirectories();
Find find = new Find();
find.setConf(conf);
PrintStream out = mock(PrintStream.class);
find.getOptions().setOut(out);
PrintStream err = mock(PrintStream.class);
find.getOptions().setErr(err);
Expression expr = mock(Expression.class);
when(expr.apply((PathData) any(), anyInt())).thenReturn(Result.PASS);
when(expr.apply(eq(item1a), anyInt())).thenReturn(Result.STOP);
FileStatusChecker fsCheck = mock(FileStatusChecker.class);
Expression test = new TestExpression(expr, fsCheck);
find.setRootExpression(test);
find.processArguments(items);
InOrder inOrder = inOrder(expr);
inOrder.verify(expr).setOptions(find.getOptions());
inOrder.verify(expr).prepare();
inOrder.verify(expr).apply(item1, 0);
inOrder.verify(expr).apply(item1a, 1);
inOrder.verify(expr).apply(item1b, 1);
inOrder.verify(expr).apply(item2, 0);
inOrder.verify(expr).apply(item3, 0);
inOrder.verify(expr).apply(item4, 0);
inOrder.verify(expr).apply(item5, 0);
inOrder.verify(expr).apply(item5a, 1);
inOrder.verify(expr).apply(item5b, 1);
inOrder.verify(expr).apply(item5c, 1);
inOrder.verify(expr).apply(item5ca, 2);
inOrder.verify(expr).apply(item5d, 1);
inOrder.verify(expr).apply(item5e, 1);
inOrder.verify(expr).finish();
verifyNoMoreInteractions(expr);
InOrder inOrderFsCheck = inOrder(fsCheck);
inOrderFsCheck.verify(fsCheck).check(item1.stat);
inOrderFsCheck.verify(fsCheck).check(item1a.stat);
inOrderFsCheck.verify(fsCheck).check(item1b.stat);
inOrderFsCheck.verify(fsCheck).check(item2.stat);
inOrderFsCheck.verify(fsCheck).check(item3.stat);
inOrderFsCheck.verify(fsCheck).check(item4.stat);
inOrderFsCheck.verify(fsCheck).check(item5.stat);
inOrderFsCheck.verify(fsCheck).check(item5a.stat);
inOrderFsCheck.verify(fsCheck).check(item5b.stat);
inOrderFsCheck.verify(fsCheck).check(item5c.stat);
inOrderFsCheck.verify(fsCheck).check(item5ca.stat);
inOrderFsCheck.verify(fsCheck).check(item5d.stat);
inOrderFsCheck.verify(fsCheck).check(item5e.stat);
verifyNoMoreInteractions(fsCheck);
verifyNoMoreInteractions(out);
verifyNoMoreInteractions(err);
}
private interface FileStatusChecker {
public void check(FileStatus fileStatus);
}
private class TestExpression extends BaseExpression implements Expression {
private Expression expr;
private FileStatusChecker checker;
public TestExpression(Expression expr, FileStatusChecker checker) {
this.expr = expr;
this.checker = checker;
}
@Override
public Result apply(PathData item, int depth) throws IOException {
FileStatus fileStatus = getFileStatus(item, depth);
checker.check(fileStatus);
return expr.apply(item, depth);
}
@Override
public void setOptions(FindOptions options) throws IOException {
super.setOptions(options);
expr.setOptions(options);
}
@Override
public void prepare() throws IOException {
expr.prepare();
}
@Override
public void finish() throws IOException {
expr.finish();
}
}
// creates a directory structure for traversal
// item1 (directory)
// \- item1a (directory)
// \- item1aa (file)
// \- item1b (file)
// item2 (directory)
// item3 (file)
// item4 (link) -> item3
// item5 (directory)
// \- item5a (link) -> item1b
// \- item5b (link) -> item5 (infinite loop)
// \- item5c (directory)
// \- item5ca (file)
// \- item5d (link) -> item5c
// \- item5e (link) -> item5c/item5ca
private PathData item1 = null;
private PathData item1a = null;
private PathData item1aa = null;
private PathData item1b = null;
private PathData item2 = null;
private PathData item3 = null;
private PathData item4 = null;
private PathData item5 = null;
private PathData item5a = null;
private PathData item5b = null;
private PathData item5c = null;
private PathData item5ca = null;
private PathData item5d = null;
private PathData item5e = null;
private LinkedList<PathData> createDirectories() throws IOException {
item1 = createPathData("item1");
item1a = createPathData("item1/item1a");
item1aa = createPathData("item1/item1a/item1aa");
item1b = createPathData("item1/item1b");
item2 = createPathData("item2");
item3 = createPathData("item3");
item4 = createPathData("item4");
item5 = createPathData("item5");
item5a = createPathData("item5/item5a");
item5b = createPathData("item5/item5b");
item5c = createPathData("item5/item5c");
item5ca = createPathData("item5/item5c/item5ca");
item5d = createPathData("item5/item5d");
item5e = createPathData("item5/item5e");
LinkedList<PathData> args = new LinkedList<PathData>();
when(item1.stat.isDirectory()).thenReturn(true);
when(item1a.stat.isDirectory()).thenReturn(true);
when(item1aa.stat.isDirectory()).thenReturn(false);
when(item1b.stat.isDirectory()).thenReturn(false);
when(item2.stat.isDirectory()).thenReturn(true);
when(item3.stat.isDirectory()).thenReturn(false);
when(item4.stat.isDirectory()).thenReturn(false);
when(item5.stat.isDirectory()).thenReturn(true);
when(item5a.stat.isDirectory()).thenReturn(false);
when(item5b.stat.isDirectory()).thenReturn(false);
when(item5c.stat.isDirectory()).thenReturn(true);
when(item5ca.stat.isDirectory()).thenReturn(false);
when(item5d.stat.isDirectory()).thenReturn(false);
when(item5e.stat.isDirectory()).thenReturn(false);
when(mockFs.listStatus(eq(item1.path))).thenReturn(
new FileStatus[] { item1a.stat, item1b.stat });
when(mockFs.listStatus(eq(item1a.path))).thenReturn(
new FileStatus[] { item1aa.stat });
when(mockFs.listStatus(eq(item2.path))).thenReturn(new FileStatus[0]);
when(mockFs.listStatus(eq(item5.path))).thenReturn(
new FileStatus[] { item5a.stat, item5b.stat, item5c.stat, item5d.stat,
item5e.stat });
when(mockFs.listStatus(eq(item5c.path))).thenReturn(
new FileStatus[] { item5ca.stat });
when(item1.stat.isSymlink()).thenReturn(false);
when(item1a.stat.isSymlink()).thenReturn(false);
when(item1aa.stat.isSymlink()).thenReturn(false);
when(item1b.stat.isSymlink()).thenReturn(false);
when(item2.stat.isSymlink()).thenReturn(false);
when(item3.stat.isSymlink()).thenReturn(false);
when(item4.stat.isSymlink()).thenReturn(true);
when(item5.stat.isSymlink()).thenReturn(false);
when(item5a.stat.isSymlink()).thenReturn(true);
when(item5b.stat.isSymlink()).thenReturn(true);
when(item5d.stat.isSymlink()).thenReturn(true);
when(item5e.stat.isSymlink()).thenReturn(true);
when(item4.stat.getSymlink()).thenReturn(item3.path);
when(item5a.stat.getSymlink()).thenReturn(item1b.path);
when(item5b.stat.getSymlink()).thenReturn(item5.path);
when(item5d.stat.getSymlink()).thenReturn(item5c.path);
when(item5e.stat.getSymlink()).thenReturn(item5ca.path);
args.add(item1);
args.add(item2);
args.add(item3);
args.add(item4);
args.add(item5);
return args;
}
private PathData createPathData(String name) throws IOException {
Path path = new Path(name);
FileStatus fstat = mock(FileStatus.class);
when(fstat.getPath()).thenReturn(path);
when(fstat.toString()).thenReturn("fileStatus:" + name);
when(mockFs.getFileStatus(eq(path))).thenReturn(fstat);
PathData item = new PathData(path.toString(), conf);
return item;
}
private LinkedList<String> getArgs(String cmd) {
return new LinkedList<String>(Arrays.asList(cmd.split(" ")));
}
}

35
hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/fs/shell/find/TestHelper.java Normal file
View File

@ -0,0 +1,35 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
/** Helper methods for the find expression unit tests. */
class TestHelper {
/** Adds an argument string to an expression */
static void addArgument(Expression expr, String arg) {
expr.addArguments(new LinkedList<String>(Collections.singletonList(arg)));
}
/** Converts a command string into a list of arguments. */
static LinkedList<String> getArgs(String cmd) {
return new LinkedList<String>(Arrays.asList(cmd.split(" ")));
}
}

93
hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/fs/shell/find/TestIname.java Normal file
View File

@ -0,0 +1,93 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import static org.junit.Assert.*;
import static org.apache.hadoop.fs.shell.find.TestHelper.*;
import java.io.IOException;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.shell.PathData;
import org.junit.Before;
import org.junit.Test;
public class TestIname {
private FileSystem mockFs;
private Name.Iname name;
@Before
public void resetMock() throws IOException {
mockFs = MockFileSystem.setup();
}
private void setup(String arg) throws IOException {
name = new Name.Iname();
addArgument(name, arg);
name.setOptions(new FindOptions());
name.prepare();
}
// test a matching name (same case)
@Test(timeout = 1000)
public void applyMatch() throws IOException {
setup("name");
PathData item = new PathData("/directory/path/name", mockFs.getConf());
assertEquals(Result.PASS, name.apply(item, -1));
}
// test a non-matching name
@Test(timeout = 1000)
public void applyNotMatch() throws IOException {
setup("name");
PathData item = new PathData("/directory/path/notname", mockFs.getConf());
assertEquals(Result.FAIL, name.apply(item, -1));
}
// test a matching name (different case)
@Test(timeout = 1000)
public void applyMixedCase() throws IOException {
setup("name");
PathData item = new PathData("/directory/path/NaMe", mockFs.getConf());
assertEquals(Result.PASS, name.apply(item, -1));
}
// test a matching glob pattern (same case)
@Test(timeout = 1000)
public void applyGlob() throws IOException {
setup("n*e");
PathData item = new PathData("/directory/path/name", mockFs.getConf());
assertEquals(Result.PASS, name.apply(item, -1));
}
// test a matching glob pattern (different case)
@Test(timeout = 1000)
public void applyGlobMixedCase() throws IOException {
setup("n*e");
PathData item = new PathData("/directory/path/NaMe", mockFs.getConf());
assertEquals(Result.PASS, name.apply(item, -1));
}
// test a non-matching glob pattern
@Test(timeout = 1000)
public void applyGlobNotMatch() throws IOException {
setup("n*e");
PathData item = new PathData("/directory/path/notmatch", mockFs.getConf());
assertEquals(Result.FAIL, name.apply(item, -1));
}
}

93
hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/fs/shell/find/TestName.java Normal file
View File

@ -0,0 +1,93 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import static org.junit.Assert.*;
import static org.apache.hadoop.fs.shell.find.TestHelper.*;
import java.io.IOException;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.shell.PathData;
import org.junit.Before;
import org.junit.Test;
public class TestName {
private FileSystem mockFs;
private Name name;
@Before
public void resetMock() throws IOException {
mockFs = MockFileSystem.setup();
}
private void setup(String arg) throws IOException {
name = new Name();
addArgument(name, arg);
name.setOptions(new FindOptions());
name.prepare();
}
// test a matching name
@Test(timeout = 1000)
public void applyMatch() throws IOException {
setup("name");
PathData item = new PathData("/directory/path/name", mockFs.getConf());
assertEquals(Result.PASS, name.apply(item, -1));
}
// test a non-matching name
@Test(timeout = 1000)
public void applyNotMatch() throws IOException {
setup("name");
PathData item = new PathData("/directory/path/notname", mockFs.getConf());
assertEquals(Result.FAIL, name.apply(item, -1));
}
// test a different case name
@Test(timeout = 1000)
public void applyMixedCase() throws IOException {
setup("name");
PathData item = new PathData("/directory/path/NaMe", mockFs.getConf());
assertEquals(Result.FAIL, name.apply(item, -1));
}
// test a matching glob pattern
@Test(timeout = 1000)
public void applyGlob() throws IOException {
setup("n*e");
PathData item = new PathData("/directory/path/name", mockFs.getConf());
assertEquals(Result.PASS, name.apply(item, -1));
}
// test a glob pattern with different case
@Test(timeout = 1000)
public void applyGlobMixedCase() throws IOException {
setup("n*e");
PathData item = new PathData("/directory/path/NaMe", mockFs.getConf());
assertEquals(Result.FAIL, name.apply(item, -1));
}
// test a non-matching glob pattern
@Test(timeout = 1000)
public void applyGlobNotMatch() throws IOException {
setup("n*e");
PathData item = new PathData("/directory/path/notmatch", mockFs.getConf());
assertEquals(Result.FAIL, name.apply(item, -1));
}
}

56
hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/fs/shell/find/TestPrint.java Normal file
View File

@ -0,0 +1,56 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import java.io.IOException;
import org.apache.hadoop.fs.shell.PathData;
import org.junit.Test;
import java.io.PrintStream;
import org.apache.hadoop.fs.FileSystem;
import org.junit.Before;
public class TestPrint {
private FileSystem mockFs;
@Before
public void resetMock() throws IOException {
mockFs = MockFileSystem.setup();
}
// test the full path is printed to stdout
@Test(timeout = 1000)
public void testPrint() throws IOException {
Print print = new Print();
PrintStream out = mock(PrintStream.class);
FindOptions options = new FindOptions();
options.setOut(out);
print.setOptions(options);
String filename = "/one/two/test";
PathData item = new PathData(filename, mockFs.getConf());
assertEquals(Result.PASS, print.apply(item, -1));
verify(out).print(filename + '\n');
verifyNoMoreInteractions(out);
}
}

56
hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/fs/shell/find/TestPrint0.java Normal file
View File

@ -0,0 +1,56 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import java.io.IOException;
import org.apache.hadoop.fs.shell.PathData;
import org.junit.Test;
import java.io.PrintStream;
import org.apache.hadoop.fs.FileSystem;
import org.junit.Before;
public class TestPrint0 {
private FileSystem mockFs;
@Before
public void resetMock() throws IOException {
mockFs = MockFileSystem.setup();
}
// test the full path is printed to stdout with a '\0'
@Test(timeout = 1000)
public void testPrint() throws IOException {
Print.Print0 print = new Print.Print0();
PrintStream out = mock(PrintStream.class);
FindOptions options = new FindOptions();
options.setOut(out);
print.setOptions(options);
String filename = "/one/two/test";
PathData item = new PathData(filename, mockFs.getConf());
assertEquals(Result.PASS, print.apply(item, -1));
verify(out).print(filename + '\0');
verifyNoMoreInteractions(out);
}
}

172
hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/fs/shell/find/TestResult.java Normal file
View File

@ -0,0 +1,172 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.fs.shell.find;
import static org.junit.Assert.*;
import org.junit.Test;
public class TestResult {
// test the PASS value
@Test(timeout = 1000)
public void testPass() {
Result result = Result.PASS;
assertTrue(result.isPass());
assertTrue(result.isDescend());
}
// test the FAIL value
@Test(timeout = 1000)
public void testFail() {
Result result = Result.FAIL;
assertFalse(result.isPass());
assertTrue(result.isDescend());
}
// test the STOP value
@Test(timeout = 1000)
public void testStop() {
Result result = Result.STOP;
assertTrue(result.isPass());
assertFalse(result.isDescend());
}
// test combine method with two PASSes
@Test(timeout = 1000)
public void combinePassPass() {
Result result = Result.PASS.combine(Result.PASS);
assertTrue(result.isPass());
assertTrue(result.isDescend());
}
// test the combine method with a PASS and a FAIL
@Test(timeout = 1000)
public void combinePassFail() {
Result result = Result.PASS.combine(Result.FAIL);
assertFalse(result.isPass());
assertTrue(result.isDescend());
}
// test the combine method with a FAIL and a PASS
@Test(timeout = 1000)
public void combineFailPass() {
Result result = Result.FAIL.combine(Result.PASS);
assertFalse(result.isPass());
assertTrue(result.isDescend());
}
// test the combine method with two FAILs
@Test(timeout = 1000)
public void combineFailFail() {
Result result = Result.FAIL.combine(Result.FAIL);
assertFalse(result.isPass());
assertTrue(result.isDescend());
}
// test the combine method with a PASS and STOP
@Test(timeout = 1000)
public void combinePassStop() {
Result result = Result.PASS.combine(Result.STOP);
assertTrue(result.isPass());
assertFalse(result.isDescend());
}
// test the combine method with a STOP and FAIL
@Test(timeout = 1000)
public void combineStopFail() {
Result result = Result.STOP.combine(Result.FAIL);
assertFalse(result.isPass());
assertFalse(result.isDescend());
}
// test the combine method with a STOP and a PASS
@Test(timeout = 1000)
public void combineStopPass() {
Result result = Result.STOP.combine(Result.PASS);
assertTrue(result.isPass());
assertFalse(result.isDescend());
}
// test the combine method with a FAIL and a STOP
@Test(timeout = 1000)
public void combineFailStop() {
Result result = Result.FAIL.combine(Result.STOP);
assertFalse(result.isPass());
assertFalse(result.isDescend());
}
// test the negation of PASS
@Test(timeout = 1000)
public void negatePass() {
Result result = Result.PASS.negate();
assertFalse(result.isPass());
assertTrue(result.isDescend());
}
// test the negation of FAIL
@Test(timeout = 1000)
public void negateFail() {
Result result = Result.FAIL.negate();
assertTrue(result.isPass());
assertTrue(result.isDescend());
}
// test the negation of STOP
@Test(timeout = 1000)
public void negateStop() {
Result result = Result.STOP.negate();
assertFalse(result.isPass());
assertFalse(result.isDescend());
}
// test equals with two PASSes
@Test(timeout = 1000)
public void equalsPass() {
Result one = Result.PASS;
Result two = Result.PASS.combine(Result.PASS);
assertEquals(one, two);
}
// test equals with two FAILs
@Test(timeout = 1000)
public void equalsFail() {
Result one = Result.FAIL;
Result two = Result.FAIL.combine(Result.FAIL);
assertEquals(one, two);
}
// test equals with two STOPS
@Test(timeout = 1000)
public void equalsStop() {
Result one = Result.STOP;
Result two = Result.STOP.combine(Result.STOP);
assertEquals(one, two);
}
// test all combinations of not equals
@Test(timeout = 1000)
public void notEquals() {
assertFalse(Result.PASS.equals(Result.FAIL));
assertFalse(Result.PASS.equals(Result.STOP));
assertFalse(Result.FAIL.equals(Result.PASS));
assertFalse(Result.FAIL.equals(Result.STOP));
assertFalse(Result.STOP.equals(Result.PASS));
assertFalse(Result.STOP.equals(Result.FAIL));
}
}

44
hadoop-common-project/hadoop-common/src/test/resources/testConf.xml
View File

@ -963,6 +963,50 @@
</comparators>
</test>
<test> <!-- TESTED -->
<description>help: help for find</description>
<test-commands>
<command>-help find</command>
</test-commands>
<cleanup-commands>
</cleanup-commands>
<comparators>
<comparator>
<type>RegexpAcrossOutputComparator</type>
<expected-output>-find &lt;path&gt; \.\.\. &lt;expression&gt; \.\.\. :
Finds all files that match the specified expression and
applies selected actions to them\. If no &lt;path&gt; is specified
then defaults to the current working directory\. If no
expression is specified then defaults to -print\.
The following primary expressions are recognised:
-name pattern
-iname pattern
Evaluates as true if the basename of the file matches the
pattern using standard file system globbing\.
If -iname is used then the match is case insensitive\.
-print
-print0
Always evaluates to true. Causes the current pathname to be
written to standard output followed by a newline. If the -print0
expression is used then an ASCII NULL character is appended rather
than a newline.
The following operators are recognised:
expression -a expression
expression -and expression
expression expression
Logical AND operator for joining two expressions\. Returns
true if both child expressions return true\. Implied by the
juxtaposition of two expressions and so does not need to be
explicitly specified\. The second expression will not be
applied if the first fails\.
</expected-output>
</comparator>
</comparators>
</test>
<test> <!-- TESTED -->
<description>help: help for help</description>
<test-commands>

223
hadoop-hdfs-project/hadoop-hdfs/src/test/resources/testHDFSConf.xml
View File

@ -16841,5 +16841,228 @@
</comparator>
</comparators>
</test>
<!-- Tests for find -->
<test> <!-- TESTED -->
<description>find: default expression</description>
<test-commands>
<command>-fs NAMENODE -mkdir /donotfind</command>
<command>-fs NAMENODE -mkdir donotfind</command>
<command>-fs NAMENODE -mkdir /findtest</command>
<command>-fs NAMENODE -mkdir /findtest/item1</command>
<command>-fs NAMENODE -mkdir /findtest/item1/item1a</command>
<command>-fs NAMENODE -touchz /findtest/item1/item1a/item1aa</command>
<command>-fs NAMENODE -put CLITEST_DATA/data60bytes /findtest/item1/item1b</command>
<command>-fs NAMENODE -put CLITEST_DATA/data60bytes /findtest/item2</command>
<command>-fs NAMENODE -mkdir /findtest/item3</command>
<command>-fs NAMENODE -mkdir /findtest/item4</command>
<command>-fs NAMENODE -mkdir /findtest/item4/item4a</command>
<command>-fs NAMENODE -put CLITEST_DATA/data120bytes /findtest/item4/item4b</command>
<command>-fs NAMENODE -put CLITEST_DATA/data1k /findtest/item5</command>
<command>-fs NAMENODE -find /findtest</command>
</test-commands>
<cleanup-commands>
<command>-fs NAMENODE -rm -r /donotfind</command>
<command>-fs NAMENODE -rm -r donotfind</command>
<command>-fs NAMENODE -rm -r /findtest</command>
</cleanup-commands>
<comparators>
<comparator>
<type>RegexpAcrossOutputComparator</type>
<expected-output>^/findtest
/findtest/item1
/findtest/item1/item1a
/findtest/item1/item1a/item1aa
/findtest/item1/item1b
/findtest/item2
/findtest/item3
/findtest/item4
/findtest/item4/item4a
/findtest/item4/item4b
/findtest/item5
$</expected-output>
</comparator>
</comparators>
</test>
<test> <!-- TESTED -->
<description>find: -print </description>
<test-commands>
<command>-fs NAMENODE -mkdir /donotfind</command>
<command>-fs NAMENODE -mkdir donotfind</command>
<command>-fs NAMENODE -mkdir /findtest</command>
<command>-fs NAMENODE -mkdir /findtest/item1</command>
<command>-fs NAMENODE -mkdir /findtest/item1/item1a</command>
<command>-fs NAMENODE -touchz /findtest/item1/item1a/item1aa</command>
<command>-fs NAMENODE -put CLITEST_DATA/data60bytes /findtest/item1/item1b</command>
<command>-fs NAMENODE -put CLITEST_DATA/data60bytes /findtest/item2</command>
<command>-fs NAMENODE -mkdir /findtest/item3</command>
<command>-fs NAMENODE -mkdir /findtest/item4</command>
<command>-fs NAMENODE -mkdir /findtest/item4/item4a</command>
<command>-fs NAMENODE -put CLITEST_DATA/data120bytes /findtest/item4/item4b</command>
<command>-fs NAMENODE -put CLITEST_DATA/data1k /findtest/item5</command>
<command>-fs NAMENODE -find /findtest -print</command>
</test-commands>
<cleanup-commands>
<command>-fs NAMENODE -rm -r /donotfind</command>
<command>-fs NAMENODE -rm -r donotfind</command>
<command>-fs NAMENODE -rm -r /findtest</command>
</cleanup-commands>
<comparators>
<comparator>
<type>RegexpAcrossOutputComparator</type>
<expected-output>^/findtest
/findtest/item1
/findtest/item1/item1a
/findtest/item1/item1a/item1aa
/findtest/item1/item1b
/findtest/item2
/findtest/item3
/findtest/item4
/findtest/item4/item4a
/findtest/item4/item4b
/findtest/item5
$</expected-output>
</comparator>
</comparators>
</test>
<test> <!-- TESTED -->
<description>find: -print (relative path) </description>
<test-commands>
<command>-fs NAMENODE -mkdir /donotfind</command>
<command>-fs NAMENODE -mkdir -p donotfind</command>
<command>-fs NAMENODE -mkdir -p findtest</command>
<command>-fs NAMENODE -mkdir -p findtest/item1</command>
<command>-fs NAMENODE -mkdir -p findtest/item1/item1a</command>
<command>-fs NAMENODE -touchz findtest/item1/item1a/item1aa</command>
<command>-fs NAMENODE -put CLITEST_DATA/data60bytes findtest/item1/item1b</command>
<command>-fs NAMENODE -put CLITEST_DATA/data60bytes findtest/item2</command>
<command>-fs NAMENODE -mkdir -p findtest/item3</command>
<command>-fs NAMENODE -mkdir -p findtest/item4</command>
<command>-fs NAMENODE -mkdir -p findtest/item4/item4a</command>
<command>-fs NAMENODE -put CLITEST_DATA/data120bytes findtest/item4/item4b</command>
<command>-fs NAMENODE -put CLITEST_DATA/data1k findtest/item5</command>
<command>-fs NAMENODE -find findtest -print</command>
</test-commands>
<cleanup-commands>
<command>-fs NAMENODE -rm -r /donotfind</command>
<command>-fs NAMENODE -rm -r donotfind</command>
<command>-fs NAMENODE -rm -r findtest</command>
</cleanup-commands>
<comparators>
<comparator>
<type>RegexpAcrossOutputComparator</type>
<expected-output>^findtest
findtest/item1
findtest/item1/item1a
findtest/item1/item1a/item1aa
findtest/item1/item1b
findtest/item2
findtest/item3
findtest/item4
findtest/item4/item4a
findtest/item4/item4b
findtest/item5
$</expected-output>
</comparator>
</comparators>
</test>
<test> <!-- TESTED -->
<description>find: -print (cwd) </description>
<test-commands>
<command>-fs NAMENODE -mkdir /donotfind</command>
<command>-fs NAMENODE -mkdir findtest</command>
<command>-fs NAMENODE -mkdir findtest/item1</command>
<command>-fs NAMENODE -mkdir findtest/item1/item1a</command>
<command>-fs NAMENODE -touchz findtest/item1/item1a/item1aa</command>
<command>-fs NAMENODE -put CLITEST_DATA/data60bytes findtest/item1/item1b</command>
<command>-fs NAMENODE -put CLITEST_DATA/data60bytes findtest/item2</command>
<command>-fs NAMENODE -mkdir findtest/item3</command>
<command>-fs NAMENODE -mkdir findtest/item4</command>
<command>-fs NAMENODE -mkdir findtest/item4/item4a</command>
<command>-fs NAMENODE -put CLITEST_DATA/data120bytes findtest/item4/item4b</command>
<command>-fs NAMENODE -put CLITEST_DATA/data1k findtest/item5</command>
<command>-fs NAMENODE -find -print</command>
</test-commands>
<cleanup-commands>
<command>-fs NAMENODE -rm -r findtest</command>
<command>-fs NAMENODE -rm -r /donotfind</command>
</cleanup-commands>
<comparators>
<comparator>
<type>RegexpAcrossOutputComparator</type>
<expected-output>^.
findtest
findtest/item1
findtest/item1/item1a
findtest/item1/item1a/item1aa
findtest/item1/item1b
findtest/item2
findtest/item3
findtest/item4
findtest/item4/item4a
findtest/item4/item4b
findtest/item5
$</expected-output>
</comparator>
</comparators>
</test>
<test> <!-- TESTED -->
<description>find: -name </description>
<test-commands>
<command>-fs NAMENODE -mkdir /findtest</command>
<command>-fs NAMENODE -mkdir /findtest/item1</command>
<command>-fs NAMENODE -mkdir /findtest/item1/item1a</command>
<command>-fs NAMENODE -touchz /findtest/item1/item1a/item1aa</command>
<command>-fs NAMENODE -put CLITEST_DATA/data60bytes /findtest/item1/item1b</command>
<command>-fs NAMENODE -put CLITEST_DATA/data60bytes /findtest/item2</command>
<command>-fs NAMENODE -mkdir /findtest/item3</command>
<command>-fs NAMENODE -mkdir /findtest/item4</command>
<command>-fs NAMENODE -mkdir /findtest/item4/item4a</command>
<command>-fs NAMENODE -put CLITEST_DATA/data120bytes /findtest/item4/item4b</command>
<command>-fs NAMENODE -put CLITEST_DATA/data1k /findtest/item5</command>
<command>-fs NAMENODE -find /findtest -name item*a</command>
</test-commands>
<cleanup-commands>
<command>-fs NAMENODE -rm -r /findtest</command>
</cleanup-commands>
<comparators>
<comparator>
<type>RegexpAcrossOutputComparator</type>
<expected-output>^/findtest/item1/item1a
/findtest/item1/item1a/item1aa
/findtest/item4/item4a
$</expected-output>
</comparator>
</comparators>
</test>
<test> <!-- TESTED -->
<description>find: -iname </description>
<test-commands>
<command>-fs NAMENODE -mkdir /findtest</command>
<command>-fs NAMENODE -mkdir /findtest/item1</command>
<command>-fs NAMENODE -mkdir /findtest/item1/item1a</command>
<command>-fs NAMENODE -touchz /findtest/item1/item1a/item1aa</command>
<command>-fs NAMENODE -put CLITEST_DATA/data60bytes /findtest/item1/item1b</command>
<command>-fs NAMENODE -put CLITEST_DATA/data60bytes /findtest/item2</command>
<command>-fs NAMENODE -mkdir /findtest/item3</command>
<command>-fs NAMENODE -mkdir /findtest/item4</command>
<command>-fs NAMENODE -mkdir /findtest/item4/item4a</command>
<command>-fs NAMENODE -put CLITEST_DATA/data120bytes /findtest/item4/item4b</command>
<command>-fs NAMENODE -put CLITEST_DATA/data1k /findtest/item5</command>
<command>-fs NAMENODE -find /findtest -iname ITEM*a</command>
</test-commands>
<cleanup-commands>
<command>-fs NAMENODE -rm -r /findtest</command>
</cleanup-commands>
<comparators>
<comparator>
<type>RegexpAcrossOutputComparator</type>
<expected-output>^/findtest/item1/item1a
/findtest/item1/item1a/item1aa
/findtest/item4/item4a
$</expected-output>
</comparator>
</comparators>
</test>
</tests>
</configuration>