accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ctubb...@apache.org
Subject [33/64] [abbrv] Merge branch '1.4.6-SNAPSHOT' into 1.5.2-SNAPSHOT
Date Wed, 09 Apr 2014 17:58:04 GMT
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;
 +}


Mime
View raw message