/**
* 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;
}
}