accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From els...@apache.org
Subject [41/50] [abbrv] git commit: Merge branch '1.6.1-SNAPSHOT'
Date Sat, 14 Jun 2014 04:36:22 GMT
Merge branch '1.6.1-SNAPSHOT'


Project: http://git-wip-us.apache.org/repos/asf/accumulo/repo
Commit: http://git-wip-us.apache.org/repos/asf/accumulo/commit/16d1f3b5
Tree: http://git-wip-us.apache.org/repos/asf/accumulo/tree/16d1f3b5
Diff: http://git-wip-us.apache.org/repos/asf/accumulo/diff/16d1f3b5

Branch: refs/heads/ACCUMULO-378
Commit: 16d1f3b56d95edefe3d497ad2b1041ba7a4a92e9
Parents: 5e44780 8717750
Author: Josh Elser <elserj@apache.org>
Authored: Thu Jun 12 22:47:21 2014 -0400
Committer: Josh Elser <elserj@apache.org>
Committed: Thu Jun 12 22:47:21 2014 -0400

----------------------------------------------------------------------
 .../main/java/org/apache/accumulo/shell/commands/ScanCommand.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/accumulo/blob/16d1f3b5/shell/src/main/java/org/apache/accumulo/shell/commands/ScanCommand.java
----------------------------------------------------------------------
diff --cc shell/src/main/java/org/apache/accumulo/shell/commands/ScanCommand.java
index 37a33a4,0000000..aac16e3
mode 100644,000000..100644
--- a/shell/src/main/java/org/apache/accumulo/shell/commands/ScanCommand.java
+++ b/shell/src/main/java/org/apache/accumulo/shell/commands/ScanCommand.java
@@@ -1,334 -1,0 +1,334 @@@
 +/*
 + * 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.accumulo.shell.commands;
 +
 +import java.io.FileNotFoundException;
 +import java.io.IOException;
 +import java.io.UnsupportedEncodingException;
 +import java.util.List;
 +import java.util.Map.Entry;
 +import java.util.concurrent.TimeUnit;
 +
 +import org.apache.accumulo.core.client.AccumuloException;
 +import org.apache.accumulo.core.client.AccumuloSecurityException;
 +import org.apache.accumulo.core.client.IteratorSetting;
 +import org.apache.accumulo.core.client.Scanner;
 +import org.apache.accumulo.core.client.ScannerBase;
 +import org.apache.accumulo.core.conf.AccumuloConfiguration;
 +import org.apache.accumulo.core.data.Key;
 +import org.apache.accumulo.core.data.Range;
 +import org.apache.accumulo.core.data.Value;
 +import org.apache.accumulo.core.security.Authorizations;
 +import org.apache.accumulo.core.util.format.BinaryFormatter;
 +import org.apache.accumulo.core.util.format.Formatter;
 +import org.apache.accumulo.core.util.interpret.DefaultScanInterpreter;
 +import org.apache.accumulo.core.util.interpret.ScanInterpreter;
 +import org.apache.accumulo.shell.Shell;
 +import org.apache.accumulo.shell.Shell.Command;
 +import org.apache.accumulo.shell.Shell.PrintFile;
 +import org.apache.accumulo.start.classloader.vfs.AccumuloVFSClassLoader;
 +import org.apache.commons.cli.CommandLine;
 +import org.apache.commons.cli.Option;
 +import org.apache.commons.cli.Options;
 +import org.apache.hadoop.io.Text;
 +
 +public class ScanCommand extends Command {
 +  
 +  private Option scanOptAuths, scanOptRow, scanOptColumns, disablePaginationOpt, showFewOpt,
formatterOpt, interpreterOpt, formatterInterpeterOpt,
 +      outputFileOpt;
 +  
 +  protected Option timestampOpt;
 +  private Option optStartRowExclusive;
 +  private Option optEndRowExclusive;
 +  private Option timeoutOption;
 +  private Option profileOpt;
 +  
 +  @Override
 +  public int execute(final String fullCommand, final CommandLine cl, final Shell shellState)
throws Exception {
 +    final PrintFile printFile = getOutputFile(cl);
 +    final String tableName = OptUtil.getTableOpt(cl, shellState);
 +    
 +    final Class<? extends Formatter> formatter = getFormatter(cl, tableName, shellState);
 +    final ScanInterpreter interpeter = getInterpreter(cl, tableName, shellState);
 +    
 +    // handle first argument, if present, the authorizations list to
 +    // scan with
 +    final Authorizations auths = getAuths(cl, shellState);
 +    final Scanner scanner = shellState.getConnector().createScanner(tableName, auths);
 +    
 +    // handle session-specific scan iterators
 +    addScanIterators(shellState, cl, scanner, tableName);
 +    
 +    // handle remaining optional arguments
 +    scanner.setRange(getRange(cl, interpeter));
 +    
 +    // handle columns
 +    fetchColumns(cl, scanner, interpeter);
 +    
 +    // set timeout
 +    scanner.setTimeout(getTimeout(cl), TimeUnit.MILLISECONDS);
 +    
 +    // output the records
 +    if (cl.hasOption(showFewOpt.getOpt())) {
 +      final String showLength = cl.getOptionValue(showFewOpt.getOpt());
 +      try {
 +        final int length = Integer.parseInt(showLength);
 +        if (length < 1) {
 +          throw new IllegalArgumentException();
 +        }
 +        BinaryFormatter.getlength(length);
 +        printBinaryRecords(cl, shellState, scanner, printFile);
 +      } catch (NumberFormatException nfe) {
 +        shellState.getReader().println("Arg must be an integer.");
 +      } catch (IllegalArgumentException iae) {
 +        shellState.getReader().println("Arg must be greater than one.");
 +      }
 +      
 +    } else {
 +      printRecords(cl, shellState, scanner, formatter, printFile);
 +    }
 +    if (printFile != null) {
 +      printFile.close();
 +    }
 +    
 +    return 0;
 +  }
 +  
 +  protected long getTimeout(final CommandLine cl) {
 +    if (cl.hasOption(timeoutOption.getLongOpt())) {
 +      return AccumuloConfiguration.getTimeInMillis(cl.getOptionValue(timeoutOption.getLongOpt()));
 +    }
 +    
 +    return Long.MAX_VALUE;
 +  }
 +  
 +  protected void addScanIterators(final Shell shellState, CommandLine cl, final Scanner
scanner, final String tableName) {
 +    
 +    List<IteratorSetting> tableScanIterators;
 +    if (cl.hasOption(profileOpt.getOpt())) {
 +      String profile = cl.getOptionValue(profileOpt.getOpt());
 +      tableScanIterators = shellState.iteratorProfiles.get(profile);
 +      
 +      if (tableScanIterators == null) {
 +        throw new IllegalArgumentException("Profile " + profile + " does not exist");
 +      }
 +    } else {
 +      tableScanIterators = shellState.scanIteratorOptions.get(tableName);
 +      if (tableScanIterators == null) {
 +        Shell.log.debug("Found no scan iterators to set");
 +        return;
 +      }
 +    }
 +    
 +    Shell.log.debug("Found " + tableScanIterators.size() + " scan iterators to set");
 +    
 +    for (IteratorSetting setting : tableScanIterators) {
 +      Shell.log.debug("Setting scan iterator " + setting.getName() + " at priority " + setting.getPriority()
+ " using class name "
 +          + setting.getIteratorClass());
 +      for (Entry<String,String> option : setting.getOptions().entrySet()) {
 +        Shell.log.debug("Setting option for " + setting.getName() + ": " + option.getKey()
+ "=" + option.getValue());
 +      }
 +      scanner.addScanIterator(setting);
 +    }
 +  }
 +  
 +  protected void printRecords(final CommandLine cl, final Shell shellState, final Iterable<Entry<Key,Value>>
scanner, final Class<? extends Formatter> formatter)
 +      throws IOException {
 +    printRecords(cl, shellState, scanner, formatter, null);
 +  }
 +  
 +  protected void printRecords(final CommandLine cl, final Shell shellState, final Iterable<Entry<Key,Value>>
scanner,
 +      final Class<? extends Formatter> formatter, PrintFile outFile) throws IOException
{
 +    if (outFile == null) {
 +      shellState.printRecords(scanner, cl.hasOption(timestampOpt.getOpt()), !cl.hasOption(disablePaginationOpt.getOpt()),
formatter);
 +    } else {
 +      shellState.printRecords(scanner, cl.hasOption(timestampOpt.getOpt()), !cl.hasOption(disablePaginationOpt.getOpt()),
formatter, outFile);
 +    }
 +  }
 +  
 +  protected void printBinaryRecords(final CommandLine cl, final Shell shellState, final
Iterable<Entry<Key,Value>> scanner) throws IOException {
 +    printBinaryRecords(cl, shellState, scanner, null);
 +  }
 +  
 +  protected void printBinaryRecords(final CommandLine cl, final Shell shellState, final
Iterable<Entry<Key,Value>> scanner, PrintFile outFile)
 +      throws IOException {
 +    if (outFile == null) {
 +      shellState.printBinaryRecords(scanner, cl.hasOption(timestampOpt.getOpt()), !cl.hasOption(disablePaginationOpt.getOpt()));
 +    } else {
 +      shellState.printBinaryRecords(scanner, cl.hasOption(timestampOpt.getOpt()), !cl.hasOption(disablePaginationOpt.getOpt()),
outFile);
 +    }
 +  }
 +  
 +  protected ScanInterpreter getInterpreter(final CommandLine cl, final String tableName,
final Shell shellState) throws Exception {
 +    
 +    Class<? extends ScanInterpreter> clazz = null;
 +    try {
 +      if (cl.hasOption(interpreterOpt.getOpt())) {
 +        clazz = AccumuloVFSClassLoader.loadClass(cl.getOptionValue(interpreterOpt.getOpt()),
ScanInterpreter.class);
 +      } else if (cl.hasOption(formatterInterpeterOpt.getOpt())) {
 +        clazz = AccumuloVFSClassLoader.loadClass(cl.getOptionValue(formatterInterpeterOpt.getOpt()),
ScanInterpreter.class);
 +      }
 +    } catch (ClassNotFoundException e) {
 +      shellState.getReader().println("Interpreter class could not be loaded.\n" + e.getMessage());
 +    }
 +    
 +    if (clazz == null)
 +      clazz = InterpreterCommand.getCurrentInterpreter(tableName, shellState);
 +    
 +    if (clazz == null)
 +      clazz = DefaultScanInterpreter.class;
 +    
 +    return clazz.newInstance();
 +  }
 +  
 +  protected Class<? extends Formatter> getFormatter(final CommandLine cl, final String
tableName, final Shell shellState) throws IOException {
 +    
 +    try {
 +      if (cl.hasOption(formatterOpt.getOpt())) {
 +        return AccumuloVFSClassLoader.loadClass(cl.getOptionValue(formatterOpt.getOpt()),
Formatter.class);
 +        
 +      } else if (cl.hasOption(formatterInterpeterOpt.getOpt())) {
 +        return AccumuloVFSClassLoader.loadClass(cl.getOptionValue(formatterInterpeterOpt.getOpt()),
Formatter.class);
 +      }
 +    } catch (ClassNotFoundException e) {
 +      shellState.getReader().println("Formatter class could not be loaded.\n" + e.getMessage());
 +    }
 +    
 +    return shellState.getFormatter(tableName);
 +  }
 +  
 +  protected void fetchColumns(final CommandLine cl, final ScannerBase scanner, final ScanInterpreter
formatter) throws UnsupportedEncodingException {
 +    if (cl.hasOption(scanOptColumns.getOpt())) {
 +      for (String a : cl.getOptionValue(scanOptColumns.getOpt()).split(",")) {
 +        final String sa[] = a.split(":", 2);
 +        if (sa.length == 1) {
 +          scanner.fetchColumnFamily(formatter.interpretColumnFamily(new Text(a.getBytes(Shell.CHARSET))));
 +        } else {
 +          scanner.fetchColumn(formatter.interpretColumnFamily(new Text(sa[0].getBytes(Shell.CHARSET))),
 +              formatter.interpretColumnQualifier(new Text(sa[1].getBytes(Shell.CHARSET))));
 +        }
 +      }
 +    }
 +  }
 +  
 +  protected Range getRange(final CommandLine cl, final ScanInterpreter formatter) throws
UnsupportedEncodingException {
 +    if ((cl.hasOption(OptUtil.START_ROW_OPT) || cl.hasOption(OptUtil.END_ROW_OPT)) &&
cl.hasOption(scanOptRow.getOpt())) {
 +      // did not see a way to make commons cli do this check... it has mutually exclusive
options but does not support the or
 +      throw new IllegalArgumentException("Options -" + scanOptRow.getOpt() + " AND (-" +
OptUtil.START_ROW_OPT + " OR -" + OptUtil.END_ROW_OPT
 +          + ") are mutally exclusive ");
 +    }
 +    
 +    if (cl.hasOption(scanOptRow.getOpt())) {
 +      return new Range(formatter.interpretRow(new Text(cl.getOptionValue(scanOptRow.getOpt()).getBytes(Shell.CHARSET))));
 +    } else {
 +      Text startRow = OptUtil.getStartRow(cl);
 +      if (startRow != null)
 +        startRow = formatter.interpretBeginRow(startRow);
 +      Text endRow = OptUtil.getEndRow(cl);
 +      if (endRow != null)
 +        endRow = formatter.interpretEndRow(endRow);
 +      final boolean startInclusive = !cl.hasOption(optStartRowExclusive.getOpt());
 +      final boolean endInclusive = !cl.hasOption(optEndRowExclusive.getOpt());
 +      return new Range(startRow, startInclusive, endRow, endInclusive);
 +    }
 +  }
 +  
 +  protected Authorizations getAuths(final CommandLine cl, final Shell shellState) throws
AccumuloSecurityException, AccumuloException {
 +    final String user = shellState.getConnector().whoami();
 +    Authorizations auths = shellState.getConnector().securityOperations().getUserAuthorizations(user);
 +    if (cl.hasOption(scanOptAuths.getOpt())) {
 +      auths = ScanCommand.parseAuthorizations(cl.getOptionValue(scanOptAuths.getOpt()));
 +    }
 +    return auths;
 +  }
 +  
 +  static Authorizations parseAuthorizations(final String field) {
 +    if (field == null || field.isEmpty()) {
 +      return Authorizations.EMPTY;
 +    }
 +    return new Authorizations(field.split(","));
 +  }
 +  
 +  @Override
 +  public String description() {
 +    return "scans the table, and displays the resulting records";
 +  }
 +  
 +  @Override
 +  public Options getOptions() {
 +    final Options o = new Options();
 +    
 +    scanOptAuths = new Option("s", "scan-authorizations", true, "scan authorizations (all
user auths are used if this argument is not specified)");
 +    optStartRowExclusive = new Option("be", "begin-exclusive", false, "make start row exclusive
(by default it's inclusive)");
 +    optStartRowExclusive.setArgName("begin-exclusive");
 +    optEndRowExclusive = new Option("ee", "end-exclusive", false, "make end row exclusive
(by default it's inclusive)");
 +    optEndRowExclusive.setArgName("end-exclusive");
 +    scanOptRow = new Option("r", "row", true, "row to scan");
 +    scanOptColumns = new Option("c", "columns", true, "comma-separated columns");
 +    timestampOpt = new Option("st", "show-timestamps", false, "display timestamps");
 +    disablePaginationOpt = new Option("np", "no-pagination", false, "disable pagination
of output");
-     showFewOpt = new Option("f", "show few", true, "show only a specified number of characters");
++    showFewOpt = new Option("f", "show-few", true, "show only a specified number of characters");
 +    formatterOpt = new Option("fm", "formatter", true, "fully qualified name of the formatter
class to use");
 +    interpreterOpt = new Option("i", "interpreter", true, "fully qualified name of the interpreter
class to use");
 +    formatterInterpeterOpt = new Option("fi", "fmt-interpreter", true, "fully qualified
name of a class that is a formatter and interpreter");
 +    timeoutOption = new Option(null, "timeout", true,
 +        "time before scan should fail if no data is returned. If no unit is given assumes
seconds.  Units d,h,m,s,and ms are supported.  e.g. 30s or 100ms");
 +    outputFileOpt = new Option("o", "output", true, "local file to write the scan output
to");
 +    
 +    scanOptAuths.setArgName("comma-separated-authorizations");
 +    scanOptRow.setArgName("row");
 +    scanOptColumns.setArgName("<columnfamily>[:<columnqualifier>]{,<columnfamily>[:<columnqualifier>]}");
 +    showFewOpt.setRequired(false);
 +    showFewOpt.setArgName("int");
 +    formatterOpt.setArgName("className");
 +    timeoutOption.setArgName("timeout");
 +    outputFileOpt.setArgName("file");
 +    
 +    profileOpt = new Option("pn", "profile", true, "iterator profile name");
 +    profileOpt.setArgName("profile");
 +    
 +    o.addOption(scanOptAuths);
 +    o.addOption(scanOptRow);
 +    o.addOption(OptUtil.startRowOpt());
 +    o.addOption(OptUtil.endRowOpt());
 +    o.addOption(optStartRowExclusive);
 +    o.addOption(optEndRowExclusive);
 +    o.addOption(scanOptColumns);
 +    o.addOption(timestampOpt);
 +    o.addOption(disablePaginationOpt);
 +    o.addOption(OptUtil.tableOpt("table to be scanned"));
 +    o.addOption(showFewOpt);
 +    o.addOption(formatterOpt);
 +    o.addOption(interpreterOpt);
 +    o.addOption(formatterInterpeterOpt);
 +    o.addOption(timeoutOption);
 +    o.addOption(outputFileOpt);
 +    o.addOption(profileOpt);
 +    
 +    return o;
 +  }
 +  
 +  @Override
 +  public int numArgs() {
 +    return 0;
 +  }
 +  
 +  protected PrintFile getOutputFile(final CommandLine cl) throws FileNotFoundException {
 +    final String outputFile = cl.getOptionValue(outputFileOpt.getOpt());
 +    return (outputFile == null ? null : new PrintFile(outputFile));
 +  }
 +}


Mime
View raw message