http://git-wip-us.apache.org/repos/asf/accumulo/blob/92613388/core/src/main/java/org/apache/accumulo/core/client/admin/InstanceOperationsImpl.java ---------------------------------------------------------------------- diff --cc core/src/main/java/org/apache/accumulo/core/client/admin/InstanceOperationsImpl.java index 156fa3a,0000000..2a1372c mode 100644,000000..100644 --- a/core/src/main/java/org/apache/accumulo/core/client/admin/InstanceOperationsImpl.java +++ b/core/src/main/java/org/apache/accumulo/core/client/admin/InstanceOperationsImpl.java @@@ -1,242 -1,0 +1,209 @@@ +/* + * 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.core.client.admin; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +import org.apache.accumulo.core.Constants; +import org.apache.accumulo.core.client.AccumuloException; +import org.apache.accumulo.core.client.AccumuloSecurityException; +import org.apache.accumulo.core.client.Instance; +import org.apache.accumulo.core.client.TableNotFoundException; +import org.apache.accumulo.core.client.impl.ClientExec; +import org.apache.accumulo.core.client.impl.ClientExecReturn; +import org.apache.accumulo.core.client.impl.MasterClient; +import org.apache.accumulo.core.client.impl.ServerClient; +import org.apache.accumulo.core.client.impl.thrift.ClientService; +import org.apache.accumulo.core.client.impl.thrift.ConfigurationType; +import org.apache.accumulo.core.client.impl.thrift.ThriftSecurityException; +import org.apache.accumulo.core.conf.Property; +import org.apache.accumulo.core.master.thrift.MasterClientService; +import org.apache.accumulo.core.security.thrift.TCredentials; +import org.apache.accumulo.core.tabletserver.thrift.TabletClientService; +import org.apache.accumulo.core.tabletserver.thrift.TabletClientService.Client; +import org.apache.accumulo.core.util.ArgumentChecker; +import org.apache.accumulo.core.util.ThriftUtil; +import org.apache.accumulo.core.zookeeper.ZooUtil; +import org.apache.accumulo.fate.zookeeper.ZooCache; +import org.apache.accumulo.trace.instrument.Tracer; +import org.apache.thrift.TException; +import org.apache.thrift.transport.TTransport; +import org.apache.thrift.transport.TTransportException; + +/** + * Provides a class for administering the accumulo instance + */ +public class InstanceOperationsImpl implements InstanceOperations { + private Instance instance; + private TCredentials credentials; + + /** + * @param instance + * the connection information for this instance + * @param credentials + * the Credential, containing principal and Authentication Token + */ + public InstanceOperationsImpl(Instance instance, TCredentials credentials) { + ArgumentChecker.notNull(instance, credentials); + this.instance = instance; + this.credentials = credentials; + } + - /* (non-Javadoc) - * @see org.apache.accumulo.core.client.admin.InstanceOperations#setProperty(java.lang.String, java.lang.String) - */ + @Override + public void setProperty(final String property, final String value) throws AccumuloException, AccumuloSecurityException { + ArgumentChecker.notNull(property, value); + MasterClient.execute(instance, new ClientExec<MasterClientService.Client>() { + @Override + public void execute(MasterClientService.Client client) throws Exception { + client.setSystemProperty(Tracer.traceInfo(), credentials, property, value); + } + }); + } + - /* (non-Javadoc) - * @see org.apache.accumulo.core.client.admin.InstanceOperations#removeProperty(java.lang.String) - */ + @Override + public void removeProperty(final String property) throws AccumuloException, AccumuloSecurityException { + ArgumentChecker.notNull(property); + MasterClient.execute(instance, new ClientExec<MasterClientService.Client>() { + @Override + public void execute(MasterClientService.Client client) throws Exception { + client.removeSystemProperty(Tracer.traceInfo(), credentials, property); + } + }); + } + - /* (non-Javadoc) - * @see org.apache.accumulo.core.client.admin.InstanceOperations#getSystemConfiguration() - */ + @Override + public Map<String,String> getSystemConfiguration() throws AccumuloException, AccumuloSecurityException { + return ServerClient.execute(instance, new ClientExecReturn<Map<String,String>,ClientService.Client>() { + @Override + public Map<String,String> execute(ClientService.Client client) throws Exception { + return client.getConfiguration(Tracer.traceInfo(), credentials, ConfigurationType.CURRENT); + } + }); + } + - /* (non-Javadoc) - * @see org.apache.accumulo.core.client.admin.InstanceOperations#getSiteConfiguration() - */ + @Override + public Map<String,String> getSiteConfiguration() throws AccumuloException, AccumuloSecurityException { + return ServerClient.execute(instance, new ClientExecReturn<Map<String,String>,ClientService.Client>() { + @Override + public Map<String,String> execute(ClientService.Client client) throws Exception { + return client.getConfiguration(Tracer.traceInfo(), credentials, ConfigurationType.SITE); + } + }); + } + - /* (non-Javadoc) - * @see org.apache.accumulo.core.client.admin.InstanceOperations#getTabletServers() - */ - + @Override + public List<String> getTabletServers() { + ZooCache cache = ZooCache.getInstance(instance.getZooKeepers(), instance.getZooKeepersSessionTimeOut()); + String path = ZooUtil.getRoot(instance) + Constants.ZTSERVERS; + List<String> results = new ArrayList<String>(); + for (String candidate : cache.getChildren(path)) { + List<String> children = cache.getChildren(path + "/" + candidate); + if (children != null && children.size() > 0) { + List<String> copy = new ArrayList<String>(children); + Collections.sort(copy); + byte[] data = cache.get(path + "/" + candidate + "/" + copy.get(0)); + if (data != null && !"master".equals(new String(data, Constants.UTF8))) { + results.add(candidate); + } + } + } + return results; + } + - /* (non-Javadoc) - * @see org.apache.accumulo.core.client.admin.InstanceOperations#getActiveScans(java.lang.String) - */ - + @Override + public List<ActiveScan> getActiveScans(String tserver) throws AccumuloException, AccumuloSecurityException { + Client client = null; + try { + client = ThriftUtil.getTServerClient(tserver, instance.getConfiguration()); + + List<ActiveScan> as = new ArrayList<ActiveScan>(); + for (org.apache.accumulo.core.tabletserver.thrift.ActiveScan activeScan : client.getActiveScans(Tracer.traceInfo(), credentials)) { + try { + as.add(new ActiveScan(instance, activeScan)); + } catch (TableNotFoundException e) { + throw new AccumuloException(e); + } + } + return as; + } catch (TTransportException e) { + throw new AccumuloException(e); + } catch (ThriftSecurityException e) { + throw new AccumuloSecurityException(e.user, e.code, e); + } catch (TException e) { + throw new AccumuloException(e); + } finally { + if (client != null) + ThriftUtil.returnClient(client); + } + } + - /* (non-Javadoc) - * @see org.apache.accumulo.core.client.admin.InstanceOperations#testClassLoad(java.lang.String, java.lang.String) - */ + @Override + public boolean testClassLoad(final String className, final String asTypeName) throws AccumuloException, AccumuloSecurityException { + return ServerClient.execute(instance, new ClientExecReturn<Boolean,ClientService.Client>() { + @Override + public Boolean execute(ClientService.Client client) throws Exception { + return client.checkClass(Tracer.traceInfo(), credentials, className, asTypeName); + } + }); + } + - /* - * (non-Javadoc) - * - * @see org.apache.accumulo.core.client.admin.InstanceOperations#getActiveCompactions(java.lang.String) - */ + @Override + public List<ActiveCompaction> getActiveCompactions(String tserver) throws AccumuloException, AccumuloSecurityException { + Client client = null; + try { + client = ThriftUtil.getTServerClient(tserver, instance.getConfiguration()); + + List<ActiveCompaction> as = new ArrayList<ActiveCompaction>(); + for (org.apache.accumulo.core.tabletserver.thrift.ActiveCompaction activeCompaction : client.getActiveCompactions(Tracer.traceInfo(), credentials)) { + as.add(new ActiveCompaction(instance, activeCompaction)); + } + return as; + } catch (TTransportException e) { + throw new AccumuloException(e); + } catch (ThriftSecurityException e) { + throw new AccumuloSecurityException(e.user, e.code, e); + } catch (TException e) { + throw new AccumuloException(e); + } finally { + if (client != null) + ThriftUtil.returnClient(client); + } + } + - /* - * (non-Javadoc) - * - * @see org.apache.accumulo.core.client.admin.InstanceOperations#ping(java.lang.String) - */ + @Override + public void ping(String tserver) throws AccumuloException { + TTransport transport = null; + try { + transport = ThriftUtil.createTransport(tserver, instance.getConfiguration().getPort(Property.TSERV_CLIENTPORT), instance.getConfiguration()); + TabletClientService.Client client = ThriftUtil.createClient(new TabletClientService.Client.Factory(), transport); + client.getTabletServerStatus(Tracer.traceInfo(), credentials); + } catch (TTransportException e) { + throw new AccumuloException(e); + } catch (ThriftSecurityException e) { + throw new AccumuloException(e); + } catch (TException e) { + throw new AccumuloException(e); + } finally { + if (transport != null) { + transport.close(); + } + } + } +}
http://git-wip-us.apache.org/repos/asf/accumulo/blob/92613388/core/src/main/java/org/apache/accumulo/core/client/admin/TableOperations.java ---------------------------------------------------------------------- diff --cc core/src/main/java/org/apache/accumulo/core/client/admin/TableOperations.java index 2521c96,0000000..0823656 mode 100644,000000..100644 --- a/core/src/main/java/org/apache/accumulo/core/client/admin/TableOperations.java +++ b/core/src/main/java/org/apache/accumulo/core/client/admin/TableOperations.java @@@ -1,719 -1,0 +1,687 @@@ +/* + * 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.core.client.admin; + +import java.io.IOException; +import java.util.Collection; +import java.util.EnumSet; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.SortedSet; + +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.TableExistsException; +import org.apache.accumulo.core.client.TableNotFoundException; +import org.apache.accumulo.core.data.Range; +import org.apache.accumulo.core.iterators.IteratorUtil.IteratorScope; +import org.apache.accumulo.core.security.Authorizations; +import org.apache.hadoop.io.Text; + +/** + * Provides a class for administering tables + * + */ + +public interface TableOperations { + + /** + * Retrieve a list of tables in Accumulo. + * + * @return List of tables in accumulo + */ + public SortedSet<String> list(); + + /** + * A method to check if a table exists in Accumulo. + * + * @param tableName + * the name of the table + * @return true if the table exists + */ + public boolean exists(String tableName); + + /** + * Create a table with no special configuration + * + * @param tableName + * the name of the table + * @throws AccumuloException + * if a general error occurs + * @throws AccumuloSecurityException + * if the user does not have permission + * @throws TableExistsException + * if the table already exists + */ + public void create(String tableName) throws AccumuloException, AccumuloSecurityException, TableExistsException; + + /** + * @param tableName + * the name of the table + * @param limitVersion + * Enables/disables the versioning iterator, which will limit the number of Key versions kept. + * @throws AccumuloException + * if a general error occurs + * @throws AccumuloSecurityException + * if the user does not have permission + * @throws TableExistsException + * if the table already exists + */ + public void create(String tableName, boolean limitVersion) throws AccumuloException, AccumuloSecurityException, TableExistsException; + + /** + * @param tableName + * the name of the table + * @param versioningIter + * Enables/disables the versioning iterator, which will limit the number of Key versions kept. + * @param timeType + * specifies logical or real-time based time recording for entries in the table + * @throws AccumuloException + * if a general error occurs + * @throws AccumuloSecurityException + * if the user does not have permission + * @throws TableExistsException + * if the table already exists + */ + public void create(String tableName, boolean versioningIter, TimeType timeType) throws AccumuloException, AccumuloSecurityException, TableExistsException; + + /** + * Imports a table exported via exportTable and copied via hadoop distcp. + * + * @param tableName + * Name of a table to create and import into. + * @param importDir + * Directory that contains the files copied by distcp from exportTable - * @throws TableExistsException - * @throws AccumuloException - * @throws AccumuloSecurityException + * @since 1.5.0 + */ + public void importTable(String tableName, String importDir) throws TableExistsException, AccumuloException, AccumuloSecurityException; + + /** + * Exports a table. The tables data is not exported, just table metadata and a list of files to distcp. The table being exported must be offline and stay + * offline for the duration of distcp. To avoid losing access to a table it can be cloned and the clone taken offline for export. + * + * <p> + * See docs/examples/README.export + * + * @param tableName + * Name of the table to export. + * @param exportDir + * An empty directory in HDFS where files containing table metadata and list of files to distcp will be placed. - * @throws TableNotFoundException - * @throws AccumuloException - * @throws AccumuloSecurityException + * @since 1.5.0 + */ + public void exportTable(String tableName, String exportDir) throws TableNotFoundException, AccumuloException, AccumuloSecurityException; + + /** + * Ensures that tablets are split along a set of keys. + * <p> + * Note that while the documentation for Text specifies that its bytestream should be UTF-8, the encoding is not enforced by operations that work with byte arrays. + * <p> + * For example, you can create 256 evenly-sliced splits via the following code sample even though the given byte sequences are not valid UTF-8. + * <pre> + * {@code + * TableOperations tableOps = connector.tableOperations(); + * TreeSet<Text> splits = new TreeSet<Text>(); + * for (int i = 0; i < 256; i++) { + * byte[] bytes = { (byte) i }; + * splits.add(new Text(bytes)); + * } + * tableOps.addSplits(TABLE_NAME, splits); + * } + * </pre> + * + * @param tableName + * the name of the table + * @param partitionKeys + * a sorted set of row key values to pre-split the table on + * @throws AccumuloException + * if a general error occurs + * @throws AccumuloSecurityException + * if the user does not have permission + * @throws TableNotFoundException + * if the table does not exist + */ + public void addSplits(String tableName, SortedSet<Text> partitionKeys) throws TableNotFoundException, AccumuloException, AccumuloSecurityException; + + /** + * @param tableName + * the name of the table + * @return the split points (end-row names) for the table's current split profile + * @throws TableNotFoundException + * if the table does not exist + * @deprecated since 1.5.0; use {@link #listSplits(String)} instead. + */ + @Deprecated + public Collection<Text> getSplits(String tableName) throws TableNotFoundException; + + /** + * @param tableName + * the name of the table + * @return the split points (end-row names) for the table's current split profile + * @throws TableNotFoundException + * if the table does not exist + * @throws AccumuloException + * if a general error occurs + * @throws AccumuloSecurityException + * if the user does not have permission + * @since 1.5.0 + */ + public Collection<Text> listSplits(String tableName) throws TableNotFoundException, AccumuloSecurityException, AccumuloException; + + /** + * @param tableName + * the name of the table + * @param maxSplits + * specifies the maximum number of splits to return + * @return the split points (end-row names) for the table's current split profile, grouped into fewer splits so as not to exceed maxSplits - * @throws TableNotFoundException + * @deprecated since 1.5.0; use {@link #listSplits(String, int)} instead. + */ + @Deprecated + public Collection<Text> getSplits(String tableName, int maxSplits) throws TableNotFoundException; + + /** + * @param tableName + * the name of the table + * @param maxSplits + * specifies the maximum number of splits to return + * @throws AccumuloException + * if a general error occurs + * @throws AccumuloSecurityException + * if the user does not have permission + * @return the split points (end-row names) for the table's current split profile, grouped into fewer splits so as not to exceed maxSplits - * @throws TableNotFoundException + * @since 1.5.0 + */ + public Collection<Text> listSplits(String tableName, int maxSplits) throws TableNotFoundException, AccumuloSecurityException, AccumuloException; + + /** + * Finds the max row within a given range. To find the max row in a table, pass null for start and end row. + * - * @param tableName + * @param auths + * find the max row that can seen with these auths + * @param startRow + * row to start looking at, null means -Infinity + * @param startInclusive + * determines if the start row is included + * @param endRow + * row to stop looking at, null means Infinity + * @param endInclusive + * determines if the end row is included + * + * @return The max row in the range, or null if there is no visible data in the range. - * - * @throws AccumuloSecurityException - * @throws AccumuloException - * @throws TableNotFoundException + */ + public Text getMaxRow(String tableName, Authorizations auths, Text startRow, boolean startInclusive, Text endRow, boolean endInclusive) + throws TableNotFoundException, AccumuloException, AccumuloSecurityException; + + /** + * Merge tablets between (start, end] + * + * @param tableName + * the table to merge + * @param start + * first tablet to be merged contains the row after this row, null means the first tablet + * @param end + * last tablet to be merged contains this row, null means the last tablet + */ + public void merge(String tableName, Text start, Text end) throws AccumuloException, AccumuloSecurityException, TableNotFoundException; + + /** + * Delete rows between (start, end] + * + * @param tableName + * the table to merge + * @param start + * delete rows after this, null means the first row of the table + * @param end + * last row to be deleted, inclusive, null means the last row of the table + */ + public void deleteRows(String tableName, Text start, Text end) throws AccumuloException, AccumuloSecurityException, TableNotFoundException; + + /** + * Starts a full major compaction of the tablets in the range (start, end]. The compaction is preformed even for tablets that have only one file. + * + * @param tableName + * the table to compact + * @param start + * first tablet to be compacted contains the row after this row, null means the first tablet in table + * @param end + * last tablet to be merged contains this row, null means the last tablet in table + * @param flush + * when true, table memory is flushed before compaction starts + * @param wait + * when true, the call will not return until compactions are finished + */ + public void compact(String tableName, Text start, Text end, boolean flush, boolean wait) throws AccumuloSecurityException, TableNotFoundException, + AccumuloException; + + /** + * Starts a full major compaction of the tablets in the range (start, end]. The compaction is preformed even for tablets that have only one file. + * + * @param tableName + * the table to compact + * @param start + * first tablet to be compacted contains the row after this row, null means the first tablet in table + * @param end + * last tablet to be merged contains this row, null means the last tablet in table + * @param iterators + * A set of iterators that will be applied to each tablet compacted + * @param flush + * when true, table memory is flushed before compaction starts + * @param wait + * when true, the call will not return until compactions are finished + * @since 1.5.0 + */ + public void compact(String tableName, Text start, Text end, List<IteratorSetting> iterators, boolean flush, boolean wait) throws AccumuloSecurityException, + TableNotFoundException, AccumuloException; + + /** + * Cancels a user initiated major compaction of a table initiated with {@link #compact(String, Text, Text, boolean, boolean)} or + * {@link #compact(String, Text, Text, List, boolean, boolean)}. Compactions of tablets that are currently running may finish, but new compactions of tablets + * will not start. + * + * @param tableName + * the name of the table + * @throws AccumuloException + * if a general error occurs + * @throws TableNotFoundException + * if the table does not exist + * @throws AccumuloSecurityException + * if the user does not have permission + * @since 1.5.0 + */ + public void cancelCompaction(String tableName) throws AccumuloSecurityException, TableNotFoundException, AccumuloException; + + /** + * Delete a table + * + * @param tableName + * the name of the table + * @throws AccumuloException + * if a general error occurs + * @throws AccumuloSecurityException + * if the user does not have permission + * @throws TableNotFoundException + * if the table does not exist + */ + public void delete(String tableName) throws AccumuloException, AccumuloSecurityException, TableNotFoundException; + + /** + * Clone a table from an existing table. The cloned table will have the same data as the source table it was created from. After cloning, the two tables can + * mutate independently. Initially the cloned table should not use any extra space, however as the source table and cloned table major compact extra space + * will be used by the clone. + * + * Initially the cloned table is only readable and writable by the user who created it. + * + * @param srcTableName + * the table to clone + * @param newTableName + * the name of the clone + * @param flush + * determines if memory is flushed in the source table before cloning. + * @param propertiesToSet + * the sources tables properties are copied, this allows overriding of those properties + * @param propertiesToExclude + * do not copy these properties from the source table, just revert to system defaults + */ + + public void clone(String srcTableName, String newTableName, boolean flush, Map<String,String> propertiesToSet, Set<String> propertiesToExclude) + throws AccumuloException, AccumuloSecurityException, TableNotFoundException, TableExistsException; + + /** + * Rename a table + * + * @param oldTableName + * the old table name + * @param newTableName + * the new table name + * @throws AccumuloException + * if a general error occurs + * @throws AccumuloSecurityException + * if the user does not have permission + * @throws TableNotFoundException + * if the old table name does not exist + * @throws TableExistsException + * if the new table name already exists + */ + public void rename(String oldTableName, String newTableName) throws AccumuloSecurityException, TableNotFoundException, AccumuloException, + TableExistsException; + + /** + * Initiate a flush of a table's data that is in memory + * + * @param tableName + * the name of the table + * @throws AccumuloException + * if a general error occurs + * @throws AccumuloSecurityException + * if the user does not have permission + * + * @deprecated As of release 1.4, replaced by {@link #flush(String, Text, Text, boolean)} + */ + @Deprecated + public void flush(String tableName) throws AccumuloException, AccumuloSecurityException; + + /** + * Flush a table's data that is currently in memory. + * + * @param tableName + * the name of the table + * @param wait + * if true the call will not return until all data present in memory when the call was is flushed if false will initiate a flush of data in memory, + * but will not wait for it to complete + * @throws AccumuloException + * if a general error occurs + * @throws AccumuloSecurityException + * if the user does not have permission - * @throws TableNotFoundException + */ + public void flush(String tableName, Text start, Text end, boolean wait) throws AccumuloException, AccumuloSecurityException, TableNotFoundException; + + /** + * Sets a property on a table. Note that it may take a short period of time (a second) to propagate the change everywhere. + * + * @param tableName + * the name of the table + * @param property + * the name of a per-table property + * @param value + * the value to set a per-table property to + * @throws AccumuloException + * if a general error occurs + * @throws AccumuloSecurityException + * if the user does not have permission + */ + public void setProperty(String tableName, String property, String value) throws AccumuloException, AccumuloSecurityException; + + /** + * Removes a property from a table. Note that it may take a short period of time (a second) to propagate the change everywhere. + * + * @param tableName + * the name of the table + * @param property + * the name of a per-table property + * @throws AccumuloException + * if a general error occurs + * @throws AccumuloSecurityException + * if the user does not have permission + */ + public void removeProperty(String tableName, String property) throws AccumuloException, AccumuloSecurityException; + + /** + * Gets properties of a table. Note that recently changed properties may not be available immediately. + * + * @param tableName + * the name of the table + * @return all properties visible by this table (system and per-table properties). Note that recently changed + * properties may not be visible immediately. + * @throws TableNotFoundException + * if the table does not exist + */ + public Iterable<Entry<String,String>> getProperties(String tableName) throws AccumuloException, TableNotFoundException; + + /** + * Sets a table's locality groups. A table's locality groups can be changed at any time. + * + * @param tableName + * the name of the table + * @param groups + * mapping of locality group names to column families in the locality group + * @throws AccumuloException + * if a general error occurs + * @throws AccumuloSecurityException + * if the user does not have permission + * @throws TableNotFoundException + * if the table does not exist + */ + public void setLocalityGroups(String tableName, Map<String,Set<Text>> groups) throws AccumuloException, AccumuloSecurityException, TableNotFoundException; + + /** + * + * Gets the locality groups currently set for a table. + * + * @param tableName + * the name of the table + * @return mapping of locality group names to column families in the locality group + * @throws AccumuloException + * if a general error occurs + * @throws TableNotFoundException + * if the table does not exist + */ + public Map<String,Set<Text>> getLocalityGroups(String tableName) throws AccumuloException, TableNotFoundException; + + /** + * @param tableName + * the name of the table + * @param range + * a range to split + * @param maxSplits + * the maximum number of splits + * @return the range, split into smaller ranges that fall on boundaries of the table's split points as evenly as possible + * @throws AccumuloException + * if a general error occurs + * @throws AccumuloSecurityException + * if the user does not have permission + * @throws TableNotFoundException + * if the table does not exist + */ + public Set<Range> splitRangeByTablets(String tableName, Range range, int maxSplits) throws AccumuloException, AccumuloSecurityException, + TableNotFoundException; + + /** + * Bulk import all the files in a directory into a table. + * + * @param tableName + * the name of the table + * @param dir + * the HDFS directory to find files for importing + * @param failureDir + * the HDFS directory to place files that failed to be imported, must exist and be empty + * @param setTime + * override the time values in the input files, and use the current time for all mutations + * @throws IOException + * when there is an error reading/writing to HDFS + * @throws AccumuloException + * when there is a general accumulo error + * @throws AccumuloSecurityException + * when the user does not have the proper permissions + * @throws TableNotFoundException + * when the table no longer exists + * + */ + public void importDirectory(String tableName, String dir, String failureDir, boolean setTime) throws TableNotFoundException, IOException, AccumuloException, + AccumuloSecurityException; + + /** + * + * @param tableName + * the table to take offline + * @throws AccumuloException + * when there is a general accumulo error + * @throws AccumuloSecurityException + * when the user does not have the proper permissions - * @throws TableNotFoundException + */ + public void offline(String tableName) throws AccumuloSecurityException, AccumuloException, TableNotFoundException; + + /** + * + * @param tableName + * the table to take online + * @throws AccumuloException + * when there is a general accumulo error + * @throws AccumuloSecurityException + * when the user does not have the proper permissions - * @throws TableNotFoundException + */ + public void online(String tableName) throws AccumuloSecurityException, AccumuloException, TableNotFoundException; + + /** + * Clears the tablet locator cache for a specified table + * + * @param tableName + * the name of the table + * @throws TableNotFoundException + * if table does not exist + */ + public void clearLocatorCache(String tableName) throws TableNotFoundException; + + /** + * Get a mapping of table name to internal table id. + * + * @return the map from table name to internal table id + */ + public Map<String,String> tableIdMap(); + + /** + * Add an iterator to a table on all scopes. + * + * @param tableName + * the name of the table + * @param setting + * object specifying the properties of the iterator + * @throws AccumuloSecurityException + * thrown if the user does not have the ability to set properties on the table - * @throws AccumuloException + * @throws TableNotFoundException + * throw if the table no longer exists + * @throws IllegalArgumentException + * if the setting conflicts with any existing iterators + */ + public void attachIterator(String tableName, IteratorSetting setting) throws AccumuloSecurityException, AccumuloException, TableNotFoundException; + + /** + * Add an iterator to a table on the given scopes. + * + * @param tableName + * the name of the table + * @param setting + * object specifying the properties of the iterator + * @throws AccumuloSecurityException + * thrown if the user does not have the ability to set properties on the table - * @throws AccumuloException + * @throws TableNotFoundException + * throw if the table no longer exists + * @throws IllegalArgumentException + * if the setting conflicts with any existing iterators + */ + public void attachIterator(String tableName, IteratorSetting setting, EnumSet<IteratorScope> scopes) throws AccumuloSecurityException, AccumuloException, + TableNotFoundException; + + /** + * Remove an iterator from a table by name. + * + * @param tableName + * the name of the table + * @param name + * the name of the iterator + * @param scopes + * the scopes of the iterator + * @throws AccumuloSecurityException + * thrown if the user does not have the ability to set properties on the table - * @throws AccumuloException + * @throws TableNotFoundException + * throw if the table no longer exists + */ + public void removeIterator(String tableName, String name, EnumSet<IteratorScope> scopes) throws AccumuloSecurityException, AccumuloException, + TableNotFoundException; + + /** + * Get the settings for an iterator. + * + * @param tableName + * the name of the table + * @param name + * the name of the iterator + * @param scope + * the scope of the iterator + * @return the settings for this iterator + * @throws AccumuloSecurityException + * thrown if the user does not have the ability to set properties on the table - * @throws AccumuloException + * @throws TableNotFoundException + * throw if the table no longer exists + */ + public IteratorSetting getIteratorSetting(String tableName, String name, IteratorScope scope) throws AccumuloSecurityException, AccumuloException, + TableNotFoundException; + + /** + * Get a list of iterators for this table. + * + * @param tableName + * the name of the table + * @return a set of iterator names - * @throws AccumuloSecurityException - * @throws AccumuloException - * @throws TableNotFoundException + */ + public Map<String,EnumSet<IteratorScope>> listIterators(String tableName) throws AccumuloSecurityException, AccumuloException, TableNotFoundException; + + /** + * Check whether a given iterator configuration conflicts with existing configuration; in particular, determine if the name or priority are already in use for + * the specified scopes. + * + * @param tableName + * the name of the table + * @param setting + * object specifying the properties of the iterator - * @throws AccumuloException - * @throws TableNotFoundException + * @throws IllegalStateException + * if the setting conflicts with any existing iterators + */ + public void checkIteratorConflicts(String tableName, IteratorSetting setting, EnumSet<IteratorScope> scopes) throws AccumuloException, TableNotFoundException; + + /** + * Add a new constraint to a table. + * + * @param tableName + * the name of the table + * @param constraintClassName + * the full name of the constraint class + * @return the unique number assigned to the constraint + * @throws AccumuloException + * thrown if the constraint has already been added to the table or if there are errors in the configuration of existing constraints + * @throws AccumuloSecurityException + * thrown if the user doesn't have permission to add the constraint - * @throws TableNotFoundException + * @since 1.5.0 + */ + public int addConstraint(String tableName, String constraintClassName) throws AccumuloException, AccumuloSecurityException, TableNotFoundException; + + /** + * Remove a constraint from a table. + * + * @param tableName + * the name of the table + * @param number + * the unique number assigned to the constraint - * @throws AccumuloException + * @throws AccumuloSecurityException + * thrown if the user doesn't have permission to remove the constraint + * @since 1.5.0 + */ + public void removeConstraint(String tableName, int number) throws AccumuloException, AccumuloSecurityException; + + /** + * List constraints on a table with their assigned numbers. + * + * @param tableName + * the name of the table + * @return a map from constraint class name to assigned number + * @throws AccumuloException + * thrown if there are errors in the configuration of existing constraints - * @throws TableNotFoundException + * @since 1.5.0 + */ + public Map<String,Integer> listConstraints(String tableName) throws AccumuloException, TableNotFoundException; + + /** + * Test to see if the instance can load the given class as the given type. This check uses the table classpath if it is set. + * - * @param className - * @param asTypeName + * @return true if the instance can load the given class as the given type, false otherwise - * @throws AccumuloException - * + * + * @since 1.5.0 + */ + public boolean testClassLoad(String tableName, final String className, final String asTypeName) throws AccumuloException, AccumuloSecurityException, + TableNotFoundException; +}