Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* 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
*
* https://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.IOException;
import java.io.PrintWriter;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
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.NamespaceNotFoundException;
import org.apache.accumulo.core.client.TableNotFoundException;
import org.apache.accumulo.core.data.Key;
import org.apache.accumulo.core.data.Value;
import org.apache.accumulo.core.iterators.IteratorUtil.IteratorScope;
import org.apache.accumulo.core.iterators.OptionDescriber;
import org.apache.accumulo.core.iterators.OptionDescriber.IteratorOptions;
import org.apache.accumulo.core.iterators.SortedKeyValueIterator;
import org.apache.accumulo.core.iterators.user.AgeOffFilter;
import org.apache.accumulo.core.iterators.user.RegExFilter;
import org.apache.accumulo.core.iterators.user.ReqVisFilter;
import org.apache.accumulo.core.iterators.user.VersioningIterator;
import org.apache.accumulo.core.metadata.MetadataTable;
import org.apache.accumulo.shell.Shell;
import org.apache.accumulo.shell.Shell.Command;
import org.apache.accumulo.shell.ShellCommandException;
import org.apache.accumulo.shell.ShellCommandException.ErrorCode;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.OptionGroup;
import org.apache.commons.cli.Options;
import org.jline.reader.LineReader;
public class SetIterCommand extends Command {
private Option allScopeOpt, mincScopeOpt, majcScopeOpt, scanScopeOpt;
Option profileOpt, priorityOpt, nameOpt;
Option ageoffTypeOpt, regexTypeOpt, versionTypeOpt, reqvisTypeOpt, classnameTypeOpt;
@Override
public int execute(final String fullCommand, final CommandLine cl, final Shell shellState)
throws AccumuloException, AccumuloSecurityException, TableNotFoundException, IOException,
ShellCommandException {
boolean tables =
cl.hasOption(OptUtil.tableOpt().getOpt()) || !shellState.getTableName().isEmpty();
boolean namespaces = cl.hasOption(OptUtil.namespaceOpt().getOpt());
final int priority = Integer.parseInt(cl.getOptionValue(priorityOpt.getOpt()));
final Map options = new HashMap<>();
String classname = cl.getOptionValue(classnameTypeOpt.getOpt());
if (cl.hasOption(regexTypeOpt.getOpt())) {
classname = RegExFilter.class.getName();
} else if (cl.hasOption(ageoffTypeOpt.getOpt())) {
classname = AgeOffFilter.class.getName();
} else if (cl.hasOption(versionTypeOpt.getOpt())) {
classname = VersioningIterator.class.getName();
} else if (cl.hasOption(reqvisTypeOpt.getOpt())) {
classname = ReqVisFilter.class.getName();
}
// ACCUMULO-4791: The SetIterCommand class as well as methods within the Shell.java class all
// require that a table or namespace be provided or otherwise they will not execute. But the
// setShellIter command does not require either of these values. In order to get around
// this requirement we will check to see if a profile name has been provided (indicating that
// we are setting a shell iterator). If so, temporarily set the table state to an
// existing table such as accumulo.metadata. This allows the command to complete successfully.
// After completion reassign the table to its original value and continue.
String currentTableName = shellState.getTableName();
String tmpTable = null;
String configuredName;
try {
if (profileOpt != null && (currentTableName == null || currentTableName.isBlank())) {
tmpTable = MetadataTable.NAME;
shellState.setTableName(tmpTable);
tables = cl.hasOption(OptUtil.tableOpt().getOpt()) || !currentTableName.isEmpty();
}
ClassLoader classloader = shellState.getClassLoader(cl, shellState);
// Get the iterator options, with potentially a name provided by the OptionDescriber impl or
// through user input
configuredName = setUpOptions(classloader, shellState.getReader(), shellState.getWriter(),
classname, options);
} finally {
// ACCUMULO-4792: reset table name and continue
if (tmpTable != null) {
shellState.setTableName(currentTableName);
}
}
// Try to get the name provided by the setiter command
String name = cl.getOptionValue(nameOpt.getOpt(), null);
// Cannot continue if no name is provided
if (name == null && configuredName == null) {
throw new IllegalArgumentException("No provided or default name for iterator");
} else if (name == null) {
// Fall back to the name from OptionDescriber or user input if none is provided on setiter
// option
name = configuredName;
}
if (namespaces) {
try {
setNamespaceProperties(cl, shellState, priority, options, classname, name);
} catch (NamespaceNotFoundException e) {
throw new IllegalArgumentException(e);
}
} else if (tables) {
setTableProperties(cl, shellState, priority, options, classname, name);
} else {
throw new IllegalArgumentException("No table or namespace specified");
}
return 0;
}
protected void setTableProperties(final CommandLine cl, final Shell shellState,
final int priority, final Map options, final String classname,
final String name) throws AccumuloException, AccumuloSecurityException, ShellCommandException,
TableNotFoundException {
// remove empty values
final String tableName = OptUtil.getTableOpt(cl, shellState);
ScanCommand.ensureTserversCanLoadIterator(shellState, tableName, classname);
options.values().removeIf(v -> v == null || v.isEmpty());
final EnumSet scopes = EnumSet.noneOf(IteratorScope.class);
if (cl.hasOption(allScopeOpt.getOpt()) || cl.hasOption(mincScopeOpt.getOpt())) {
scopes.add(IteratorScope.minc);
}
if (cl.hasOption(allScopeOpt.getOpt()) || cl.hasOption(majcScopeOpt.getOpt())) {
scopes.add(IteratorScope.majc);
}
if (cl.hasOption(allScopeOpt.getOpt()) || cl.hasOption(scanScopeOpt.getOpt())) {
scopes.add(IteratorScope.scan);
}
if (scopes.isEmpty()) {
throw new IllegalArgumentException("You must select at least one scope to configure");
}
final IteratorSetting setting = new IteratorSetting(priority, name, classname, options);
shellState.getAccumuloClient().tableOperations().attachIterator(tableName, setting, scopes);
}
protected void setNamespaceProperties(final CommandLine cl, final Shell shellState,
final int priority, final Map options, final String classname,
final String name) throws AccumuloException, AccumuloSecurityException, ShellCommandException,
NamespaceNotFoundException {
// remove empty values
final String namespace = OptUtil.getNamespaceOpt(cl, shellState);
if (!shellState.getAccumuloClient().namespaceOperations().testClassLoad(namespace, classname,
SortedKeyValueIterator.class.getName())) {
throw new ShellCommandException(ErrorCode.INITIALIZATION_FAILURE,
"Servers are unable to load " + classname + " as type "
+ SortedKeyValueIterator.class.getName());
}
options.values().removeIf(v -> v == null || v.isEmpty());
final EnumSet scopes = EnumSet.noneOf(IteratorScope.class);
if (cl.hasOption(allScopeOpt.getOpt()) || cl.hasOption(mincScopeOpt.getOpt())) {
scopes.add(IteratorScope.minc);
}
if (cl.hasOption(allScopeOpt.getOpt()) || cl.hasOption(majcScopeOpt.getOpt())) {
scopes.add(IteratorScope.majc);
}
if (cl.hasOption(allScopeOpt.getOpt()) || cl.hasOption(scanScopeOpt.getOpt())) {
scopes.add(IteratorScope.scan);
}
if (scopes.isEmpty()) {
throw new IllegalArgumentException("You must select at least one scope to configure");
}
final IteratorSetting setting = new IteratorSetting(priority, name, classname, options);
shellState.getAccumuloClient().namespaceOperations().attachIterator(namespace, setting, scopes);
}
private static String setUpOptions(ClassLoader classloader, final LineReader reader,
final PrintWriter writer, final String className, final Map options)
throws IOException, ShellCommandException {
String input;
SortedKeyValueIterator skvi;
String clazzName;
try {
@SuppressWarnings("unchecked")
var clazz = (Class>) classloader
.loadClass(className).asSubclass(SortedKeyValueIterator.class);
clazzName = clazz.getName();
skvi = clazz.getDeclaredConstructor().newInstance();
} catch (ReflectiveOperationException e) {
StringBuilder msg = new StringBuilder("Unable to load ").append(className);
if (className.indexOf('.') < 0) {
msg.append("; did you use a fully qualified package name?");
} else {
msg.append("; class not found.");
}
throw new ShellCommandException(ErrorCode.INITIALIZATION_FAILURE, msg.toString());
} catch (ClassCastException e) {
String msg = className + " loaded successfully but does not implement SortedKeyValueIterator."
+ " This class cannot be used with this command.";
throw new ShellCommandException(ErrorCode.INITIALIZATION_FAILURE, msg);
}
OptionDescriber iterOptions = null;
if (OptionDescriber.class.isAssignableFrom(skvi.getClass())) {
iterOptions = (OptionDescriber) skvi;
}
String iteratorName;
if (iterOptions != null) {
final IteratorOptions itopts = iterOptions.describeOptions();
iteratorName = itopts.getName();
if (iteratorName == null) {
throw new IllegalArgumentException(
className + " described its default distinguishing name as null");
}
String shortClassName = className;
if (className.contains(".")) {
shortClassName = className.substring(className.lastIndexOf('.') + 1);
}
final Map localOptions = new HashMap<>();
do {
// clean up the overall options that caused things to fail
for (String key : localOptions.keySet()) {
options.remove(key);
}
localOptions.clear();
writer.println(itopts.getDescription());
String prompt;
if (itopts.getNamedOptions() != null) {
for (Entry e : itopts.getNamedOptions().entrySet()) {
prompt = Shell.repeat("-", 10) + "> set " + shortClassName + " parameter " + e.getKey()
+ ", " + e.getValue() + ": ";
writer.flush();
input = reader.readLine(prompt);
if (input == null) {
writer.println();
throw new IOException("Input stream closed");
}
// Places all Parameters and Values into the LocalOptions, even if the value is "".
// This allows us to check for "" values when setting the iterators and allows us to
// remove
// the parameter and value from the table property.
localOptions.put(e.getKey(), input);
}
}
if (itopts.getUnnamedOptionDescriptions() != null) {
for (String desc : itopts.getUnnamedOptionDescriptions()) {
writer.println(Shell.repeat("-", 10) + "> entering options: " + desc);
input = "start";
prompt = Shell.repeat("-", 10) + "> set " + shortClassName
+ " option (, hit enter to skip): ";
while (true) {
writer.flush();
input = reader.readLine(prompt);
if (input == null) {
writer.println();
throw new IOException("Input stream closed");
} else {
input = new String(input);
}
if (input.isEmpty())
break;
String[] sa = input.split(" ", 2);
localOptions.put(sa[0], sa[1]);
}
}
}
options.putAll(localOptions);
if (!iterOptions.validateOptions(options))
writer.println("invalid options for " + clazzName);
} while (!iterOptions.validateOptions(options));
} else {
writer.flush();
writer.println("The iterator class does not implement OptionDescriber."
+ " Consider this for better iterator configuration using this setiter command.");
iteratorName = reader.readLine("Name for iterator (enter to skip): ");
if (iteratorName == null) {
writer.println();
throw new IOException("Input stream closed");
} else if (iteratorName.isBlank()) {
// Treat whitespace or empty string as no name provided
iteratorName = null;
}
writer.flush();
writer.println("Optional, configure name-value options for iterator:");
String prompt = Shell.repeat("-", 10) + "> set option (, hit enter to skip): ";
final HashMap localOptions = new HashMap<>();
while (true) {
writer.flush();
input = reader.readLine(prompt);
if (input == null) {
writer.println();
throw new IOException("Input stream closed");
} else if (input.isBlank()) {
break;
}
String[] sa = input.split(" ", 2);
localOptions.put(sa[0], sa[1]);
}
options.putAll(localOptions);
}
return iteratorName;
}
@Override
public String description() {
return "sets a table-specific or namespace-specific iterator";
}
// Set all options common to both iterators and shell iterators
protected void setBaseOptions(Options options) {
setPriorityOptions(options);
setNameOptions(options);
setIteratorTypeOptions(options);
}
private void setNameOptions(Options options) {
nameOpt = new Option("n", "name", true, "iterator to set");
nameOpt.setArgName("itername");
options.addOption(nameOpt);
}
private void setPriorityOptions(Options options) {
priorityOpt = new Option("p", "priority", true, "the order in which the iterator is applied");
priorityOpt.setArgName("pri");
priorityOpt.setRequired(true);
options.addOption(priorityOpt);
}
@Override
public Options getOptions() {
final Options o = new Options();
setBaseOptions(o);
setScopeOptions(o);
setTableOptions(o);
return o;
}
private void setScopeOptions(Options o) {
allScopeOpt =
new Option("all", "all-scopes", false, "applied at scan time, minor and major compactions");
mincScopeOpt = new Option(IteratorScope.minc.name(), "minor-compaction", false,
"applied at minor compaction");
majcScopeOpt = new Option(IteratorScope.majc.name(), "major-compaction", false,
"applied at major compaction");
scanScopeOpt =
new Option(IteratorScope.scan.name(), "scan-time", false, "applied at scan time");
o.addOption(allScopeOpt);
o.addOption(mincScopeOpt);
o.addOption(majcScopeOpt);
o.addOption(scanScopeOpt);
}
private void setTableOptions(Options o) {
final OptionGroup tableGroup = new OptionGroup();
tableGroup.addOption(OptUtil.tableOpt("table to configure iterators on"));
tableGroup.addOption(OptUtil.namespaceOpt("namespace to configure iterators on"));
o.addOptionGroup(tableGroup);
}
private void setIteratorTypeOptions(Options o) {
final OptionGroup typeGroup = new OptionGroup();
classnameTypeOpt = new Option("class", "class-name", true,
"a java class that implements SortedKeyValueIterator");
classnameTypeOpt.setArgName("name");
regexTypeOpt = new Option("regex", "regular-expression", false, "a regex matching iterator");
versionTypeOpt = new Option("vers", "version", false, "a versioning iterator");
reqvisTypeOpt = new Option("reqvis", "require-visibility", false,
"an iterator that omits entries with empty visibilities");
ageoffTypeOpt = new Option("ageoff", "ageoff", false, "an aging off iterator");
typeGroup.addOption(classnameTypeOpt);
typeGroup.addOption(regexTypeOpt);
typeGroup.addOption(versionTypeOpt);
typeGroup.addOption(reqvisTypeOpt);
typeGroup.addOption(ageoffTypeOpt);
typeGroup.setRequired(true);
o.addOptionGroup(typeGroup);
}
@Override
public int numArgs() {
return 0;
}
}
