accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ctubb...@apache.org
Subject [accumulo] branch main updated: Validate table/namespace names in public API (#1971)
Date Mon, 07 Jun 2021 21:02:18 GMT
This is an automated email from the ASF dual-hosted git repository.

ctubbsii pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/accumulo.git


The following commit(s) were added to refs/heads/main by this push:
     new 58a559f  Validate table/namespace names in public API (#1971)
58a559f is described below

commit 58a559fa6ac7c5137b5cd1418b0de457f7cad2a9
Author: slackwinner <50567198+slackwinner@users.noreply.github.com>
AuthorDate: Mon Jun 7 17:02:05 2021 -0400

    Validate table/namespace names in public API (#1971)
    
    Throw IllegalArgumentException in Public API consistently
    after validating table and namespace names
    
    In response to issue apache/accumulo#1953 this commit
    contains changes to allow fast failure and achieve
    consistent behavior when a table or namespace name
    is invalid.
---
 .../java/org/apache/accumulo/core/Constants.java   |   2 -
 .../accumulo/core/clientImpl/ClientContext.java    |  33 ++++
 .../accumulo/core/clientImpl/ConnectorImpl.java    |  29 +++
 .../core/clientImpl/NamespaceOperationsImpl.java   |  56 +++++-
 .../accumulo/core/clientImpl/Namespaces.java       |   5 +-
 .../core/clientImpl/SecurityOperationsImpl.java    |  26 +++
 .../core/clientImpl/TableOperationsHelper.java     |  38 ++++
 .../core/clientImpl/TableOperationsImpl.java       | 216 ++++++++++++++++-----
 .../apache/accumulo/core/clientImpl/Tables.java    |  24 ++-
 .../accumulo/manager/FateServiceHandler.java       |   4 +-
 .../accumulo/manager/util/TableValidators.java     |   4 +-
 .../shell/commands/CreateTableCommand.java         |   2 +-
 .../org/apache/accumulo/test/NamespacesIT.java     |   2 +-
 .../apache/accumulo/test/TableOperationsIT.java    |   2 +-
 14 files changed, 367 insertions(+), 76 deletions(-)

diff --git a/core/src/main/java/org/apache/accumulo/core/Constants.java b/core/src/main/java/org/apache/accumulo/core/Constants.java
index e2fac29..8559656 100644
--- a/core/src/main/java/org/apache/accumulo/core/Constants.java
+++ b/core/src/main/java/org/apache/accumulo/core/Constants.java
@@ -117,6 +117,4 @@ public class Constants {
 
   public static final int DEFAULT_VISIBILITY_CACHE_SIZE = 1000;
 
-  public static final int MAX_TABLE_NAME_LEN = 1024;
-  public static final int MAX_NAMESPACE_LEN = 1024;
 }
diff --git a/core/src/main/java/org/apache/accumulo/core/clientImpl/ClientContext.java b/core/src/main/java/org/apache/accumulo/core/clientImpl/ClientContext.java
index 6219188..60c0c5b 100644
--- a/core/src/main/java/org/apache/accumulo/core/clientImpl/ClientContext.java
+++ b/core/src/main/java/org/apache/accumulo/core/clientImpl/ClientContext.java
@@ -98,6 +98,7 @@ public class ClientContext implements AccumuloClient {
   private final ClientInfo info;
   private String instanceId;
   private final ZooCache zooCache;
+  private static final String VALID_TABLENAME_REGEX = "^(\\w{1,1024}[.])?(\\w{1,1024})$";
 
   private Credentials creds;
   private BatchWriterConfig batchWriterConfig;
@@ -509,6 +510,10 @@ public class ClientContext implements AccumuloClient {
   }
 
   TableId getTableId(String tableName) throws TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     TableId tableId = Tables.getTableId(this, tableName);
     if (Tables.getTableState(this, tableId) == TableState.OFFLINE)
       throw new TableOfflineException(Tables.getTableOfflineMsg(this, tableId));
@@ -520,6 +525,10 @@ public class ClientContext implements AccumuloClient {
       int numQueryThreads) throws TableNotFoundException {
     checkArgument(tableName != null, "tableName is null");
     checkArgument(authorizations != null, "authorizations is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     ensureOpen();
     return new TabletServerBatchReader(this, getTableId(tableName), authorizations,
         numQueryThreads);
@@ -547,6 +556,10 @@ public class ClientContext implements AccumuloClient {
       int numQueryThreads, BatchWriterConfig config) throws TableNotFoundException {
     checkArgument(tableName != null, "tableName is null");
     checkArgument(authorizations != null, "authorizations is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     ensureOpen();
     return new TabletServerBatchDeleter(this, getTableId(tableName), authorizations,
         numQueryThreads, config.merge(getBatchWriterConfig()));
@@ -563,6 +576,10 @@ public class ClientContext implements AccumuloClient {
   public BatchWriter createBatchWriter(String tableName, BatchWriterConfig config)
       throws TableNotFoundException {
     checkArgument(tableName != null, "tableName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     ensureOpen();
     // we used to allow null inputs for bw config
     if (config == null) {
@@ -573,6 +590,10 @@ public class ClientContext implements AccumuloClient {
 
   @Override
   public BatchWriter createBatchWriter(String tableName) throws TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     return createBatchWriter(tableName, new BatchWriterConfig());
   }
 
@@ -590,6 +611,10 @@ public class ClientContext implements AccumuloClient {
   @Override
   public ConditionalWriter createConditionalWriter(String tableName, ConditionalWriterConfig config)
       throws TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     ensureOpen();
     if (config == null) {
       config = new ConditionalWriterConfig();
@@ -609,6 +634,10 @@ public class ClientContext implements AccumuloClient {
       throws TableNotFoundException {
     checkArgument(tableName != null, "tableName is null");
     checkArgument(authorizations != null, "authorizations is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     ensureOpen();
     Scanner scanner = new ScannerImpl(this, getTableId(tableName), authorizations);
     Integer batchSize = ClientProperty.SCANNER_BATCH_SIZE.getInteger(getProperties());
@@ -621,6 +650,10 @@ public class ClientContext implements AccumuloClient {
   @Override
   public Scanner createScanner(String tableName)
       throws TableNotFoundException, AccumuloSecurityException, AccumuloException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     Authorizations auths = securityOperations().getUserAuthorizations(getPrincipal());
     return createScanner(tableName, auths);
   }
diff --git a/core/src/main/java/org/apache/accumulo/core/clientImpl/ConnectorImpl.java b/core/src/main/java/org/apache/accumulo/core/clientImpl/ConnectorImpl.java
index b609611..3ffe85f 100644
--- a/core/src/main/java/org/apache/accumulo/core/clientImpl/ConnectorImpl.java
+++ b/core/src/main/java/org/apache/accumulo/core/clientImpl/ConnectorImpl.java
@@ -54,6 +54,7 @@ public class ConnectorImpl extends org.apache.accumulo.core.client.Connector {
   private static final String SYSTEM_TOKEN_NAME =
       "org.apache.accumulo.server.security.SystemCredentials$SystemToken";
   private final ClientContext context;
+  private static final String VALID_TABLENAME_REGEX = "^(\\w{1,1024}[.])?(\\w{1,1024})$";
 
   public ConnectorImpl(ClientContext context) throws AccumuloSecurityException, AccumuloException {
     this.context = context;
@@ -85,6 +86,10 @@ public class ConnectorImpl extends org.apache.accumulo.core.client.Connector {
   @Override
   public BatchScanner createBatchScanner(String tableName, Authorizations authorizations,
       int numQueryThreads) throws TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     return context.createBatchScanner(tableName, authorizations, numQueryThreads);
   }
 
@@ -94,6 +99,10 @@ public class ConnectorImpl extends org.apache.accumulo.core.client.Connector {
       throws TableNotFoundException {
     checkArgument(tableName != null, "tableName is null");
     checkArgument(authorizations != null, "authorizations is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     return new TabletServerBatchDeleter(context, context.getTableId(tableName), authorizations,
         numQueryThreads, new BatchWriterConfig().setMaxMemory(maxMemory)
             .setMaxLatency(maxLatency, TimeUnit.MILLISECONDS).setMaxWriteThreads(maxWriteThreads));
@@ -102,6 +111,10 @@ public class ConnectorImpl extends org.apache.accumulo.core.client.Connector {
   @Override
   public BatchDeleter createBatchDeleter(String tableName, Authorizations authorizations,
       int numQueryThreads, BatchWriterConfig config) throws TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     return context.createBatchDeleter(tableName, authorizations, numQueryThreads, config);
   }
 
@@ -109,6 +122,10 @@ public class ConnectorImpl extends org.apache.accumulo.core.client.Connector {
   public BatchWriter createBatchWriter(String tableName, long maxMemory, long maxLatency,
       int maxWriteThreads) throws TableNotFoundException {
     checkArgument(tableName != null, "tableName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     return new BatchWriterImpl(context, context.getTableId(tableName),
         new BatchWriterConfig().setMaxMemory(maxMemory)
             .setMaxLatency(maxLatency, TimeUnit.MILLISECONDS).setMaxWriteThreads(maxWriteThreads));
@@ -117,6 +134,10 @@ public class ConnectorImpl extends org.apache.accumulo.core.client.Connector {
   @Override
   public BatchWriter createBatchWriter(String tableName, BatchWriterConfig config)
       throws TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     return context.createBatchWriter(tableName, config);
   }
 
@@ -135,12 +156,20 @@ public class ConnectorImpl extends org.apache.accumulo.core.client.Connector {
   @Override
   public ConditionalWriter createConditionalWriter(String tableName, ConditionalWriterConfig config)
       throws TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     return context.createConditionalWriter(tableName, config);
   }
 
   @Override
   public Scanner createScanner(String tableName, Authorizations authorizations)
       throws TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     return context.createScanner(tableName, authorizations);
   }
 
diff --git a/core/src/main/java/org/apache/accumulo/core/clientImpl/NamespaceOperationsImpl.java b/core/src/main/java/org/apache/accumulo/core/clientImpl/NamespaceOperationsImpl.java
index 678cee0..a33482c 100644
--- a/core/src/main/java/org/apache/accumulo/core/clientImpl/NamespaceOperationsImpl.java
+++ b/core/src/main/java/org/apache/accumulo/core/clientImpl/NamespaceOperationsImpl.java
@@ -20,8 +20,6 @@ package org.apache.accumulo.core.clientImpl;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.apache.accumulo.core.Constants.MAX_NAMESPACE_LEN;
-import static org.apache.accumulo.core.Constants.MAX_TABLE_NAME_LEN;
 
 import java.nio.ByteBuffer;
 import java.util.Arrays;
@@ -65,6 +63,7 @@ public class NamespaceOperationsImpl extends NamespaceOperationsHelper {
   private TableOperationsImpl tableOps;
 
   private static final Logger log = LoggerFactory.getLogger(TableOperations.class);
+  private static final String VALID_NAMESPACE_REGEX = "^\\w{0,1024}$";
 
   public NamespaceOperationsImpl(ClientContext context, TableOperationsImpl tableOps) {
     checkArgument(context != null, "context is null");
@@ -96,6 +95,9 @@ public class NamespaceOperationsImpl extends NamespaceOperationsHelper {
   @Override
   public boolean exists(String namespace) {
     checkArgument(namespace != null, "namespace is null");
+    checkArgument(namespace.matches(VALID_NAMESPACE_REGEX),
+        "namespace must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     OpTimer timer = null;
 
@@ -120,8 +122,10 @@ public class NamespaceOperationsImpl extends NamespaceOperationsHelper {
   public void create(String namespace)
       throws AccumuloException, AccumuloSecurityException, NamespaceExistsException {
     checkArgument(namespace != null, "namespace is null");
-    checkArgument(namespace.length() <= MAX_NAMESPACE_LEN,
-        "Namespace is longer than " + MAX_NAMESPACE_LEN + " characters");
+    checkArgument(namespace.matches(VALID_NAMESPACE_REGEX),
+        "namespace must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     try {
       doNamespaceFateOperation(FateOperation.NAMESPACE_CREATE,
           Arrays.asList(ByteBuffer.wrap(namespace.getBytes(UTF_8))), Collections.emptyMap(),
@@ -136,8 +140,11 @@ public class NamespaceOperationsImpl extends NamespaceOperationsHelper {
   public void delete(String namespace) throws AccumuloException, AccumuloSecurityException,
       NamespaceNotFoundException, NamespaceNotEmptyException {
     checkArgument(namespace != null, "namespace is null");
-    NamespaceId namespaceId = Namespaces.getNamespaceId(context, namespace);
+    checkArgument(namespace.matches(VALID_NAMESPACE_REGEX),
+        "namespace must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
+    NamespaceId namespaceId = Namespaces.getNamespaceId(context, namespace);
     if (namespaceId.equals(Namespace.ACCUMULO.id()) || namespaceId.equals(Namespace.DEFAULT.id())) {
       Credentials credentials = context.getCredentials();
       log.debug("{} attempted to delete the {} namespace", credentials.getPrincipal(), namespaceId);
@@ -165,8 +172,14 @@ public class NamespaceOperationsImpl extends NamespaceOperationsHelper {
   public void rename(String oldNamespaceName, String newNamespaceName)
       throws AccumuloSecurityException, NamespaceNotFoundException, AccumuloException,
       NamespaceExistsException {
-    checkArgument(newNamespaceName.length() <= MAX_TABLE_NAME_LEN,
-        "Namespace is longer than " + MAX_TABLE_NAME_LEN + " characters");
+    checkArgument(oldNamespaceName.matches(VALID_NAMESPACE_REGEX),
+        "oldNamespaceName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
+    checkArgument(newNamespaceName.matches(VALID_NAMESPACE_REGEX),
+        "newNamespaceName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     List<ByteBuffer> args = Arrays.asList(ByteBuffer.wrap(oldNamespaceName.getBytes(UTF_8)),
         ByteBuffer.wrap(newNamespaceName.getBytes(UTF_8)));
     Map<String,String> opts = new HashMap<>();
@@ -179,6 +192,9 @@ public class NamespaceOperationsImpl extends NamespaceOperationsHelper {
     checkArgument(namespace != null, "namespace is null");
     checkArgument(property != null, "property is null");
     checkArgument(value != null, "value is null");
+    checkArgument(namespace.matches(VALID_NAMESPACE_REGEX),
+        "namespace must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     ManagerClient.executeNamespace(context,
         client -> client.setNamespaceProperty(TraceUtil.traceInfo(), context.rpcCreds(), namespace,
@@ -191,6 +207,9 @@ public class NamespaceOperationsImpl extends NamespaceOperationsHelper {
       throws AccumuloException, AccumuloSecurityException, NamespaceNotFoundException {
     checkArgument(namespace != null, "namespace is null");
     checkArgument(property != null, "property is null");
+    checkArgument(namespace.matches(VALID_NAMESPACE_REGEX),
+        "namespace must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     ManagerClient.executeNamespace(context, client -> client
         .removeNamespaceProperty(TraceUtil.traceInfo(), context.rpcCreds(), namespace, property));
@@ -201,6 +220,10 @@ public class NamespaceOperationsImpl extends NamespaceOperationsHelper {
   public Map<String,String> getConfiguration(final String namespace)
       throws AccumuloException, NamespaceNotFoundException {
     checkArgument(namespace != null, "namespace is null");
+    checkArgument(namespace.matches(VALID_NAMESPACE_REGEX),
+        "namespace must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     try {
       return ServerClient.executeRaw(context, client -> client
           .getNamespaceConfiguration(TraceUtil.traceInfo(), context.rpcCreds(), namespace));
@@ -234,6 +257,9 @@ public class NamespaceOperationsImpl extends NamespaceOperationsHelper {
     checkArgument(namespace != null, "namespace is null");
     checkArgument(className != null, "className is null");
     checkArgument(asTypeName != null, "asTypeName is null");
+    checkArgument(namespace.matches(VALID_NAMESPACE_REGEX),
+        "namespace must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     try {
       return ServerClient.executeRaw(context,
@@ -259,6 +285,10 @@ public class NamespaceOperationsImpl extends NamespaceOperationsHelper {
   public void attachIterator(String namespace, IteratorSetting setting,
       EnumSet<IteratorScope> scopes)
       throws AccumuloSecurityException, AccumuloException, NamespaceNotFoundException {
+    checkArgument(namespace.matches(VALID_NAMESPACE_REGEX),
+        "namespace must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     testClassLoad(namespace, setting.getIteratorClass(), SortedKeyValueIterator.class.getName());
     super.attachIterator(namespace, setting, scopes);
   }
@@ -266,6 +296,10 @@ public class NamespaceOperationsImpl extends NamespaceOperationsHelper {
   @Override
   public int addConstraint(String namespace, String constraintClassName)
       throws AccumuloException, AccumuloSecurityException, NamespaceNotFoundException {
+    checkArgument(namespace.matches(VALID_NAMESPACE_REGEX),
+        "namespace must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     testClassLoad(namespace, constraintClassName, Constraint.class.getName());
     return super.addConstraint(namespace, constraintClassName);
   }
@@ -273,6 +307,10 @@ public class NamespaceOperationsImpl extends NamespaceOperationsHelper {
   private String doNamespaceFateOperation(FateOperation op, List<ByteBuffer> args,
       Map<String,String> opts, String namespace) throws AccumuloSecurityException,
       AccumuloException, NamespaceExistsException, NamespaceNotFoundException {
+    checkArgument(namespace.matches(VALID_NAMESPACE_REGEX),
+        "namespace must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     try {
       return tableOps.doFateOperation(op, args, opts, namespace);
     } catch (TableExistsException | TableNotFoundException e) {
@@ -283,6 +321,10 @@ public class NamespaceOperationsImpl extends NamespaceOperationsHelper {
 
   private void checkLocalityGroups(String namespace, String propChanged)
       throws AccumuloException, NamespaceNotFoundException {
+    checkArgument(namespace.matches(VALID_NAMESPACE_REGEX),
+        "namespace must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     if (LocalityGroupUtil.isLocalityGroupProperty(propChanged)) {
       Map<String,String> allProps = getConfiguration(namespace);
       try {
diff --git a/core/src/main/java/org/apache/accumulo/core/clientImpl/Namespaces.java b/core/src/main/java/org/apache/accumulo/core/clientImpl/Namespaces.java
index a365876..74d3411 100644
--- a/core/src/main/java/org/apache/accumulo/core/clientImpl/Namespaces.java
+++ b/core/src/main/java/org/apache/accumulo/core/clientImpl/Namespaces.java
@@ -40,11 +40,11 @@ import org.slf4j.LoggerFactory;
 public class Namespaces {
   private static final Logger log = LoggerFactory.getLogger(Namespaces.class);
 
-  public static final String VALID_NAME_REGEX = "^\\w*$";
+  public static final String VALID_NAMESPACE_REGEX = "^\\w{0,1024}$";
   public static final Validator<String> VALID_NAME = new Validator<>() {
     @Override
     public boolean test(String namespace) {
-      return namespace != null && namespace.matches(VALID_NAME_REGEX);
+      return namespace != null && namespace.matches(VALID_NAMESPACE_REGEX);
     }
 
     @Override
@@ -55,7 +55,6 @@ public class Namespaces {
           + namespace;
     }
   };
-
   public static final Validator<String> NOT_DEFAULT = new Validator<>() {
     @Override
     public boolean test(String namespace) {
diff --git a/core/src/main/java/org/apache/accumulo/core/clientImpl/SecurityOperationsImpl.java b/core/src/main/java/org/apache/accumulo/core/clientImpl/SecurityOperationsImpl.java
index 94a6dbf..fabb446 100644
--- a/core/src/main/java/org/apache/accumulo/core/clientImpl/SecurityOperationsImpl.java
+++ b/core/src/main/java/org/apache/accumulo/core/clientImpl/SecurityOperationsImpl.java
@@ -49,6 +49,7 @@ import org.apache.accumulo.core.util.ByteBufferUtil;
 public class SecurityOperationsImpl implements SecurityOperations {
 
   private final ClientContext context;
+  private static final String VALID_NAMESPACE_REGEX = "^\\w{0,1024}$";
 
   private void executeVoid(ClientExec<ClientService.Client> exec)
       throws AccumuloException, AccumuloSecurityException {
@@ -104,6 +105,7 @@ public class SecurityOperationsImpl implements SecurityOperations {
     if (context.getSaslParams() == null) {
       checkArgument(password != null, "password is null");
     }
+
     executeVoid(client -> {
       if (context.getSaslParams() == null) {
         client.createLocalUser(TraceUtil.traceInfo(), context.rpcCreds(), principal,
@@ -119,6 +121,7 @@ public class SecurityOperationsImpl implements SecurityOperations {
   public void dropLocalUser(final String principal)
       throws AccumuloException, AccumuloSecurityException {
     checkArgument(principal != null, "principal is null");
+
     executeVoid(
         client -> client.dropLocalUser(TraceUtil.traceInfo(), context.rpcCreds(), principal));
   }
@@ -128,6 +131,7 @@ public class SecurityOperationsImpl implements SecurityOperations {
       throws AccumuloException, AccumuloSecurityException {
     checkArgument(principal != null, "principal is null");
     checkArgument(token != null, "token is null");
+
     final Credentials toAuth = new Credentials(principal, token);
     return execute(client -> client.authenticateUser(TraceUtil.traceInfo(), context.rpcCreds(),
         toAuth.toThrift(context.getInstanceID())));
@@ -138,6 +142,7 @@ public class SecurityOperationsImpl implements SecurityOperations {
       throws AccumuloException, AccumuloSecurityException {
     checkArgument(principal != null, "principal is null");
     checkArgument(token != null, "token is null");
+
     final Credentials toChange = new Credentials(principal, token);
     executeVoid(client -> client.changeLocalUserPassword(TraceUtil.traceInfo(), context.rpcCreds(),
         principal, ByteBuffer.wrap(token.getPassword())));
@@ -151,6 +156,7 @@ public class SecurityOperationsImpl implements SecurityOperations {
       throws AccumuloException, AccumuloSecurityException {
     checkArgument(principal != null, "principal is null");
     checkArgument(authorizations != null, "authorizations is null");
+
     executeVoid(client -> client.changeAuthorizations(TraceUtil.traceInfo(), context.rpcCreds(),
         principal, ByteBufferUtil.toByteBuffers(authorizations.getAuthorizations())));
   }
@@ -159,6 +165,7 @@ public class SecurityOperationsImpl implements SecurityOperations {
   public Authorizations getUserAuthorizations(final String principal)
       throws AccumuloException, AccumuloSecurityException {
     checkArgument(principal != null, "principal is null");
+
     return execute(client -> new Authorizations(
         client.getUserAuthorizations(TraceUtil.traceInfo(), context.rpcCreds(), principal)));
   }
@@ -168,6 +175,7 @@ public class SecurityOperationsImpl implements SecurityOperations {
       throws AccumuloException, AccumuloSecurityException {
     checkArgument(principal != null, "principal is null");
     checkArgument(perm != null, "perm is null");
+
     return execute(client -> client.hasSystemPermission(TraceUtil.traceInfo(), context.rpcCreds(),
         principal, perm.getId()));
   }
@@ -178,6 +186,7 @@ public class SecurityOperationsImpl implements SecurityOperations {
     checkArgument(principal != null, "principal is null");
     checkArgument(table != null, "table is null");
     checkArgument(perm != null, "perm is null");
+
     try {
       return execute(client -> client.hasTablePermission(TraceUtil.traceInfo(), context.rpcCreds(),
           principal, table, perm.getId()));
@@ -195,6 +204,10 @@ public class SecurityOperationsImpl implements SecurityOperations {
     checkArgument(principal != null, "principal is null");
     checkArgument(namespace != null, "namespace is null");
     checkArgument(permission != null, "permission is null");
+    checkArgument(namespace.matches(VALID_NAMESPACE_REGEX),
+        "namespace must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     return execute(client -> client.hasNamespacePermission(TraceUtil.traceInfo(),
         context.rpcCreds(), principal, namespace, permission.getId()));
   }
@@ -204,6 +217,7 @@ public class SecurityOperationsImpl implements SecurityOperations {
       throws AccumuloException, AccumuloSecurityException {
     checkArgument(principal != null, "principal is null");
     checkArgument(permission != null, "permission is null");
+
     executeVoid(client -> client.grantSystemPermission(TraceUtil.traceInfo(), context.rpcCreds(),
         principal, permission.getId()));
   }
@@ -214,6 +228,7 @@ public class SecurityOperationsImpl implements SecurityOperations {
     checkArgument(principal != null, "principal is null");
     checkArgument(table != null, "table is null");
     checkArgument(permission != null, "permission is null");
+
     try {
       executeVoid(client -> client.grantTablePermission(TraceUtil.traceInfo(), context.rpcCreds(),
           principal, table, permission.getId()));
@@ -231,6 +246,10 @@ public class SecurityOperationsImpl implements SecurityOperations {
     checkArgument(principal != null, "principal is null");
     checkArgument(namespace != null, "namespace is null");
     checkArgument(permission != null, "permission is null");
+    checkArgument(namespace.matches(VALID_NAMESPACE_REGEX),
+        "namespace must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     executeVoid(client -> client.grantNamespacePermission(TraceUtil.traceInfo(), context.rpcCreds(),
         principal, namespace, permission.getId()));
   }
@@ -240,6 +259,7 @@ public class SecurityOperationsImpl implements SecurityOperations {
       throws AccumuloException, AccumuloSecurityException {
     checkArgument(principal != null, "principal is null");
     checkArgument(permission != null, "permission is null");
+
     executeVoid(client -> client.revokeSystemPermission(TraceUtil.traceInfo(), context.rpcCreds(),
         principal, permission.getId()));
   }
@@ -250,6 +270,7 @@ public class SecurityOperationsImpl implements SecurityOperations {
     checkArgument(principal != null, "principal is null");
     checkArgument(table != null, "table is null");
     checkArgument(permission != null, "permission is null");
+
     try {
       executeVoid(client -> client.revokeTablePermission(TraceUtil.traceInfo(), context.rpcCreds(),
           principal, table, permission.getId()));
@@ -267,6 +288,10 @@ public class SecurityOperationsImpl implements SecurityOperations {
     checkArgument(principal != null, "principal is null");
     checkArgument(namespace != null, "namespace is null");
     checkArgument(permission != null, "permission is null");
+    checkArgument(namespace.matches(VALID_NAMESPACE_REGEX),
+        "namespace must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     executeVoid(client -> client.revokeNamespacePermission(TraceUtil.traceInfo(),
         context.rpcCreds(), principal, namespace, permission.getId()));
   }
@@ -280,6 +305,7 @@ public class SecurityOperationsImpl implements SecurityOperations {
   public DelegationToken getDelegationToken(DelegationTokenConfig cfg)
       throws AccumuloException, AccumuloSecurityException {
     final TDelegationTokenConfig tConfig;
+
     if (cfg != null) {
       tConfig = DelegationTokenConfigSerializer.serialize(cfg);
     } else {
diff --git a/core/src/main/java/org/apache/accumulo/core/clientImpl/TableOperationsHelper.java b/core/src/main/java/org/apache/accumulo/core/clientImpl/TableOperationsHelper.java
index 28c6307..9843346 100644
--- a/core/src/main/java/org/apache/accumulo/core/clientImpl/TableOperationsHelper.java
+++ b/core/src/main/java/org/apache/accumulo/core/clientImpl/TableOperationsHelper.java
@@ -37,9 +37,15 @@ import org.apache.accumulo.core.iterators.IteratorUtil.IteratorScope;
 
 public abstract class TableOperationsHelper implements TableOperations {
 
+  public static final String VALID_TABLENAME_REGEX = "^(\\w{1,1024}[.])?(\\w{1,1024})$";
+
   @Override
   public void attachIterator(String tableName, IteratorSetting setting)
       throws AccumuloSecurityException, AccumuloException, TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     attachIterator(tableName, setting, EnumSet.allOf(IteratorScope.class));
   }
 
@@ -50,7 +56,11 @@ public abstract class TableOperationsHelper implements TableOperations {
     checkArgument(tableName != null, "tableName is null");
     checkArgument(setting != null, "setting is null");
     checkArgument(scopes != null, "scopes is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
     checkIteratorConflicts(tableName, setting, scopes);
+
     for (IteratorScope scope : scopes) {
       String root = String.format("%s%s.%s", Property.TABLE_ITERATOR_PREFIX,
           scope.name().toLowerCase(), setting.getName());
@@ -64,6 +74,10 @@ public abstract class TableOperationsHelper implements TableOperations {
   @Override
   public void removeIterator(String tableName, String name, EnumSet<IteratorScope> scopes)
       throws AccumuloSecurityException, AccumuloException, TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     Map<String,String> copy = Map.copyOf(this.getConfiguration(tableName));
     for (IteratorScope scope : scopes) {
       String root = String.format("%s%s.%s", Property.TABLE_ITERATOR_PREFIX,
@@ -81,6 +95,10 @@ public abstract class TableOperationsHelper implements TableOperations {
     checkArgument(tableName != null, "tableName is null");
     checkArgument(name != null, "name is null");
     checkArgument(scope != null, "scope is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     int priority = -1;
     String classname = null;
     Map<String,String> settings = new HashMap<>();
@@ -109,6 +127,10 @@ public abstract class TableOperationsHelper implements TableOperations {
   @Override
   public Map<String,EnumSet<IteratorScope>> listIterators(String tableName)
       throws AccumuloException, TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     Map<String,EnumSet<IteratorScope>> result = new TreeMap<>();
     for (Entry<String,String> property : this.getProperties(tableName)) {
       String name = property.getKey();
@@ -168,6 +190,10 @@ public abstract class TableOperationsHelper implements TableOperations {
   public void checkIteratorConflicts(String tableName, IteratorSetting setting,
       EnumSet<IteratorScope> scopes) throws AccumuloException, TableNotFoundException {
     checkArgument(tableName != null, "tableName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     Map<String,String> iteratorProps = Map.copyOf(this.getConfiguration(tableName));
     checkIteratorConflicts(iteratorProps, setting, scopes);
   }
@@ -175,6 +201,10 @@ public abstract class TableOperationsHelper implements TableOperations {
   @Override
   public int addConstraint(String tableName, String constraintClassName)
       throws AccumuloException, AccumuloSecurityException, TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     TreeSet<Integer> constraintNumbers = new TreeSet<>();
     TreeMap<String,Integer> constraintClasses = new TreeMap<>();
     int i;
@@ -204,12 +234,20 @@ public abstract class TableOperationsHelper implements TableOperations {
   @Override
   public void removeConstraint(String tableName, int number)
       throws AccumuloException, AccumuloSecurityException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     this.removeProperty(tableName, Property.TABLE_CONSTRAINT_PREFIX.toString() + number);
   }
 
   @Override
   public Map<String,Integer> listConstraints(String tableName)
       throws AccumuloException, TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     Map<String,Integer> constraints = new TreeMap<>();
     for (Entry<String,String> property : this.getProperties(tableName)) {
       if (property.getKey().startsWith(Property.TABLE_CONSTRAINT_PREFIX.toString())) {
diff --git a/core/src/main/java/org/apache/accumulo/core/clientImpl/TableOperationsImpl.java b/core/src/main/java/org/apache/accumulo/core/clientImpl/TableOperationsImpl.java
index 2631eed..52ae9e2 100644
--- a/core/src/main/java/org/apache/accumulo/core/clientImpl/TableOperationsImpl.java
+++ b/core/src/main/java/org/apache/accumulo/core/clientImpl/TableOperationsImpl.java
@@ -24,7 +24,6 @@ import static java.util.Objects.requireNonNull;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static java.util.stream.Collectors.toSet;
-import static org.apache.accumulo.core.Constants.MAX_TABLE_NAME_LEN;
 import static org.apache.accumulo.core.metadata.schema.TabletMetadata.ColumnType.LOCATION;
 import static org.apache.accumulo.core.metadata.schema.TabletMetadata.ColumnType.PREV_ROW;
 import static org.apache.accumulo.fate.util.UtilWaitThread.sleepUninterruptibly;
@@ -156,6 +155,8 @@ import com.google.common.base.Preconditions;
 public class TableOperationsImpl extends TableOperationsHelper {
 
   public static final String CLONE_EXCLUDE_PREFIX = "!";
+  public static final String VALID_TABLENAME_REGEX = "^(\\w{1,1024}[.])?(\\w{1,1024})$";
+
   private static final Logger log = LoggerFactory.getLogger(TableOperations.class);
   private final ClientContext context;
 
@@ -188,6 +189,10 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public boolean exists(String tableName) {
     checkArgument(tableName != null, "tableName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     if (tableName.equals(MetadataTable.NAME) || tableName.equals(RootTable.NAME))
       return true;
 
@@ -212,6 +217,10 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public void create(String tableName)
       throws AccumuloException, AccumuloSecurityException, TableExistsException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     create(tableName, new NewTableConfiguration());
   }
 
@@ -220,8 +229,9 @@ public class TableOperationsImpl extends TableOperationsHelper {
       throws AccumuloException, AccumuloSecurityException, TableExistsException {
     checkArgument(tableName != null, "tableName is null");
     checkArgument(ntc != null, "ntc is null");
-    checkArgument(tableName.length() <= MAX_TABLE_NAME_LEN,
-        "Table name is longer than " + MAX_TABLE_NAME_LEN + " characters");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     List<ByteBuffer> args = new ArrayList<>();
     args.add(ByteBuffer.wrap(tableName.getBytes(UTF_8)));
@@ -269,8 +279,8 @@ public class TableOperationsImpl extends TableOperationsHelper {
     }
   }
 
-  // This method is for retrying in the case of network failures; anything else it passes to the
-  // caller to deal with
+  // This method is for retrying in the case of network failures;
+  // anything else it passes to the caller to deal with
   private void executeFateOperation(long opid, FateOperation op, List<ByteBuffer> args,
       Map<String,String> opts, boolean autoCleanUp)
       throws ThriftSecurityException, TException, ThriftTableOperationException {
@@ -336,6 +346,10 @@ public class TableOperationsImpl extends TableOperationsHelper {
 
   public String doBulkFateOperation(List<ByteBuffer> args, String tableName)
       throws AccumuloSecurityException, AccumuloException, TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     try {
       return doFateOperation(FateOperation.TABLE_BULK_IMPORT2, args, Collections.emptyMap(),
           tableName);
@@ -453,9 +467,8 @@ public class TableOperationsImpl extends TableOperationsHelper {
 
         int mid = splits.size() / 2;
 
-        // split the middle split point to ensure that child task split different tablets and can
-        // therefore
-        // run in parallel
+        // split the middle split point to ensure that child task split
+        // different tablets and can therefore run in parallel
         addSplits(env.tableName, new TreeSet<>(splits.subList(mid, mid + 1)), env.tableId);
         env.latch.countDown();
 
@@ -472,13 +485,16 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public void addSplits(String tableName, SortedSet<Text> partitionKeys)
       throws TableNotFoundException, AccumuloException, AccumuloSecurityException {
-    TableId tableId = Tables.getTableId(context, tableName);
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
+    TableId tableId = Tables.getTableId(context, tableName);
     List<Text> splits = new ArrayList<>(partitionKeys);
-    // should be sorted because we copied from a sorted set, but that makes assumptions about
-    // how the copy was done so resort to be sure.
-    Collections.sort(splits);
 
+    // should be sorted because we copied from a sorted set, but that makes
+    // assumptions about how the copy was done so resort to be sure.
+    Collections.sort(splits);
     CountDownLatch latch = new CountDownLatch(splits.size());
     AtomicReference<Exception> exception = new AtomicReference<>(null);
 
@@ -526,8 +542,11 @@ public class TableOperationsImpl extends TableOperationsHelper {
   private void addSplits(String tableName, SortedSet<Text> partitionKeys, TableId tableId)
       throws AccumuloException, AccumuloSecurityException, TableNotFoundException,
       AccumuloServerException {
-    TabletLocator tabLocator = TabletLocator.getLocator(context, tableId);
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
+    TabletLocator tabLocator = TabletLocator.getLocator(context, tableId);
     for (Text split : partitionKeys) {
       boolean successful = false;
       int attempt = 0;
@@ -613,8 +632,11 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public void merge(String tableName, Text start, Text end)
       throws AccumuloException, AccumuloSecurityException, TableNotFoundException {
-
     checkArgument(tableName != null, "tableName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     ByteBuffer EMPTY = ByteBuffer.allocate(0);
     List<ByteBuffer> args = Arrays.asList(ByteBuffer.wrap(tableName.getBytes(UTF_8)),
         start == null ? EMPTY : TextUtil.getByteBuffer(start),
@@ -632,8 +654,11 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public void deleteRows(String tableName, Text start, Text end)
       throws AccumuloException, AccumuloSecurityException, TableNotFoundException {
-
     checkArgument(tableName != null, "tableName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     ByteBuffer EMPTY = ByteBuffer.allocate(0);
     List<ByteBuffer> args = Arrays.asList(ByteBuffer.wrap(tableName.getBytes(UTF_8)),
         start == null ? EMPTY : TextUtil.getByteBuffer(start),
@@ -651,17 +676,22 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public Collection<Text> listSplits(String tableName)
       throws TableNotFoundException, AccumuloSecurityException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     return _listSplits(tableName);
   }
 
   private List<Text> _listSplits(String tableName)
       throws TableNotFoundException, AccumuloSecurityException {
     checkArgument(tableName != null, "tableName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     TableId tableId = Tables.getTableId(context, tableName);
-
     TreeMap<KeyExtent,String> tabletLocations = new TreeMap<>();
-
     while (true) {
       try {
         tabletLocations.clear();
@@ -685,7 +715,6 @@ public class TableOperationsImpl extends TableOperationsHelper {
     }
 
     ArrayList<Text> endRows = new ArrayList<>(tabletLocations.size());
-
     for (KeyExtent ke : tabletLocations.keySet())
       if (ke.endRow() != null)
         endRows.add(ke.endRow());
@@ -697,16 +726,17 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public Collection<Text> listSplits(String tableName, int maxSplits)
       throws TableNotFoundException, AccumuloSecurityException {
-    List<Text> endRows = _listSplits(tableName);
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
+    List<Text> endRows = _listSplits(tableName);
     if (endRows.size() <= maxSplits)
       return endRows;
 
     double r = (maxSplits + 1) / (double) (endRows.size());
     double pos = 0;
-
     ArrayList<Text> subset = new ArrayList<>(maxSplits);
-
     int j = 0;
     for (int i = 0; i < endRows.size() && j < maxSplits; i++) {
       pos += r;
@@ -724,10 +754,12 @@ public class TableOperationsImpl extends TableOperationsHelper {
   public void delete(String tableName)
       throws AccumuloException, AccumuloSecurityException, TableNotFoundException {
     checkArgument(tableName != null, "tableName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     List<ByteBuffer> args = Arrays.asList(ByteBuffer.wrap(tableName.getBytes(UTF_8)));
     Map<String,String> opts = new HashMap<>();
-
     try {
       doTableFateOperation(tableName, TableNotFoundException.class, FateOperation.TABLE_DELETE,
           args, opts);
@@ -755,8 +787,13 @@ public class TableOperationsImpl extends TableOperationsHelper {
 
     checkArgument(srcTableName != null, "srcTableName is null");
     checkArgument(newTableName != null, "newTableName is null");
-    checkArgument(newTableName.length() <= MAX_TABLE_NAME_LEN,
-        "Table name is longer than " + MAX_TABLE_NAME_LEN + " characters");
+    checkArgument(srcTableName.matches(VALID_TABLENAME_REGEX),
+        "srcTableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
+    checkArgument(newTableName.matches(VALID_TABLENAME_REGEX),
+        "newTableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     TableId srcTableId = Tables.getTableId(context, srcTableName);
 
@@ -792,8 +829,14 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public void rename(String oldTableName, String newTableName) throws AccumuloSecurityException,
       TableNotFoundException, AccumuloException, TableExistsException {
-    checkArgument(newTableName.length() <= MAX_TABLE_NAME_LEN,
-        "Table name is longer than " + MAX_TABLE_NAME_LEN + " characters");
+    checkArgument(oldTableName.matches(VALID_TABLENAME_REGEX),
+        "oldTableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
+    checkArgument(newTableName.matches(VALID_TABLENAME_REGEX),
+        "newTableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     List<ByteBuffer> args = Arrays.asList(ByteBuffer.wrap(oldTableName.getBytes(UTF_8)),
         ByteBuffer.wrap(newTableName.getBytes(UTF_8)));
     Map<String,String> opts = new HashMap<>();
@@ -803,6 +846,10 @@ public class TableOperationsImpl extends TableOperationsHelper {
 
   @Override
   public void flush(String tableName) throws AccumuloException, AccumuloSecurityException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     try {
       flush(tableName, null, null, false);
     } catch (TableNotFoundException e) {
@@ -814,6 +861,9 @@ public class TableOperationsImpl extends TableOperationsHelper {
   public void flush(String tableName, Text start, Text end, boolean wait)
       throws AccumuloException, AccumuloSecurityException, TableNotFoundException {
     checkArgument(tableName != null, "tableName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     TableId tableId = Tables.getTableId(context, tableName);
     _flush(tableId, start, end, wait);
@@ -837,6 +887,9 @@ public class TableOperationsImpl extends TableOperationsHelper {
   public void compact(String tableName, CompactionConfig config)
       throws AccumuloSecurityException, TableNotFoundException, AccumuloException {
     checkArgument(tableName != null, "tableName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     // Ensure compaction iterators exist on a tabletserver
     final String skviName = SortedKeyValueIterator.class.getName();
@@ -868,7 +921,6 @@ public class TableOperationsImpl extends TableOperationsHelper {
     }
 
     TableId tableId = Tables.getTableId(context, tableName);
-
     Text start = config.getStartRow();
     Text end = config.getEndRow();
 
@@ -877,8 +929,8 @@ public class TableOperationsImpl extends TableOperationsHelper {
 
     List<ByteBuffer> args = Arrays.asList(ByteBuffer.wrap(tableId.canonical().getBytes(UTF_8)),
         ByteBuffer.wrap(UserCompactionUtils.encode(config)));
-
     Map<String,String> opts = new HashMap<>();
+
     try {
       doFateOperation(FateOperation.TABLE_COMPACT, args, opts, tableName, config.getWait());
     } catch (TableExistsException | NamespaceExistsException e) {
@@ -905,11 +957,14 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public void cancelCompaction(String tableName)
       throws AccumuloSecurityException, TableNotFoundException, AccumuloException {
-    TableId tableId = Tables.getTableId(context, tableName);
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
+    TableId tableId = Tables.getTableId(context, tableName);
     List<ByteBuffer> args = Arrays.asList(ByteBuffer.wrap(tableId.canonical().getBytes(UTF_8)));
-
     Map<String,String> opts = new HashMap<>();
+
     try {
       doTableFateOperation(tableName, TableNotFoundException.class,
           FateOperation.TABLE_CANCEL_COMPACT, args, opts);
@@ -922,7 +977,6 @@ public class TableOperationsImpl extends TableOperationsHelper {
 
   private void _flush(TableId tableId, Text start, Text end, boolean wait)
       throws AccumuloException, AccumuloSecurityException, TableNotFoundException {
-
     try {
       long flushID;
 
@@ -994,6 +1048,10 @@ public class TableOperationsImpl extends TableOperationsHelper {
     checkArgument(tableName != null, "tableName is null");
     checkArgument(property != null, "property is null");
     checkArgument(value != null, "value is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     try {
       setPropertyNoChecks(tableName, property, value);
 
@@ -1015,6 +1073,10 @@ public class TableOperationsImpl extends TableOperationsHelper {
       throws AccumuloException, AccumuloSecurityException {
     checkArgument(tableName != null, "tableName is null");
     checkArgument(property != null, "property is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     try {
       removePropertyNoChecks(tableName, property);
 
@@ -1051,6 +1113,10 @@ public class TableOperationsImpl extends TableOperationsHelper {
   public Map<String,String> getConfiguration(final String tableName)
       throws AccumuloException, TableNotFoundException {
     checkArgument(tableName != null, "tableName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     try {
       return ServerClient.executeRaw(context, client -> client
           .getTableConfiguration(TraceUtil.traceInfo(), context.rpcCreds(), tableName));
@@ -1111,10 +1177,11 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public Map<String,Set<Text>> getLocalityGroups(String tableName)
       throws AccumuloException, TableNotFoundException {
+
     AccumuloConfiguration conf = new ConfigurationCopy(this.getProperties(tableName));
     Map<String,Set<ByteSequence>> groups = LocalityGroupUtil.getLocalityGroups(conf);
-
     Map<String,Set<Text>> groups2 = new HashMap<>();
+
     for (Entry<String,Set<ByteSequence>> entry : groups.entrySet()) {
 
       HashSet<Text> colFams = new HashSet<>();
@@ -1134,6 +1201,10 @@ public class TableOperationsImpl extends TableOperationsHelper {
       throws AccumuloException, AccumuloSecurityException, TableNotFoundException {
     checkArgument(tableName != null, "tableName is null");
     checkArgument(range != null, "range is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     if (maxSplits < 1)
       throw new IllegalArgumentException("maximum splits must be >= 1");
     if (maxSplits == 1)
@@ -1225,9 +1296,12 @@ public class TableOperationsImpl extends TableOperationsHelper {
     checkArgument(tableName != null, "tableName is null");
     checkArgument(dir != null, "dir is null");
     checkArgument(failureDir != null, "failureDir is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     // check for table existence
     Tables.getTableId(context, tableName);
-
     Path dirPath = checkPath(dir, "Bulk", "");
     Path failPath = checkPath(failureDir, "Bulk", "failure");
 
@@ -1248,12 +1322,10 @@ public class TableOperationsImpl extends TableOperationsHelper {
 
   private void waitForTableStateTransition(TableId tableId, TableState expectedState)
       throws AccumuloException, TableNotFoundException {
-
     Text startRow = null;
     Text lastRow = null;
 
     while (true) {
-
       if (Tables.getTableState(context, tableId) != expectedState) {
         Tables.clearCache(context);
         TableState currentState = Tables.getTableState(context, tableId);
@@ -1286,7 +1358,6 @@ public class TableOperationsImpl extends TableOperationsHelper {
 
       for (TabletMetadata tablet : tablets) {
         total++;
-
         Location loc = tablet.getLocation();
 
         if ((expectedState == TableState.ONLINE
@@ -1352,8 +1423,11 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public void offline(String tableName, boolean wait)
       throws AccumuloSecurityException, AccumuloException, TableNotFoundException {
-
     checkArgument(tableName != null, "tableName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     TableId tableId = Tables.getTableId(context, tableName);
     List<ByteBuffer> args = Arrays.asList(ByteBuffer.wrap(tableId.canonical().getBytes(UTF_8)));
     Map<String,String> opts = new HashMap<>();
@@ -1373,9 +1447,11 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public boolean isOnline(String tableName) throws AccumuloException, TableNotFoundException {
     checkArgument(tableName != null, "tableName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     TableId tableId = Tables.getTableId(context, tableName);
-
     TableState expectedState = Tables.getTableState(context, tableId, true);
     return expectedState == TableState.ONLINE;
   }
@@ -1390,13 +1466,14 @@ public class TableOperationsImpl extends TableOperationsHelper {
   public void online(String tableName, boolean wait)
       throws AccumuloSecurityException, AccumuloException, TableNotFoundException {
     checkArgument(tableName != null, "tableName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     TableId tableId = Tables.getTableId(context, tableName);
-
     /**
      * ACCUMULO-4574 if table is already online return without executing fate operation.
      */
-
     if (isOnline(tableName)) {
       if (wait)
         waitForTableStateTransition(tableId, TableState.ONLINE);
@@ -1421,6 +1498,10 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public void clearLocatorCache(String tableName) throws TableNotFoundException {
     checkArgument(tableName != null, "tableName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "Table name must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     TabletLocator tabLocator =
         TabletLocator.getLocator(context, Tables.getTableId(context, tableName));
     tabLocator.invalidateCache();
@@ -1438,7 +1519,10 @@ public class TableOperationsImpl extends TableOperationsHelper {
   public Text getMaxRow(String tableName, Authorizations auths, Text startRow,
       boolean startInclusive, Text endRow, boolean endInclusive) throws TableNotFoundException {
     checkArgument(tableName != null, "tableName is null");
-    checkArgument(auths != null, "auths is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     Scanner scanner = context.createScanner(tableName, auths);
     return FindMax.findMax(scanner, startRow, startInclusive, endRow, endInclusive);
   }
@@ -1563,8 +1647,9 @@ public class TableOperationsImpl extends TableOperationsHelper {
       throws TableExistsException, AccumuloException, AccumuloSecurityException {
     checkArgument(tableName != null, "tableName is null");
     checkArgument(importDirs != null, "importDir is null");
-    checkArgument(tableName.length() <= MAX_TABLE_NAME_LEN,
-        "Table name is longer than " + MAX_TABLE_NAME_LEN + " characters");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     Set<String> checkedImportDirs = new HashSet<>();
     try {
@@ -1623,10 +1708,12 @@ public class TableOperationsImpl extends TableOperationsHelper {
       throws TableNotFoundException, AccumuloException, AccumuloSecurityException {
     checkArgument(tableName != null, "tableName is null");
     checkArgument(exportDir != null, "exportDir is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     List<ByteBuffer> args = Arrays.asList(ByteBuffer.wrap(tableName.getBytes(UTF_8)),
         ByteBuffer.wrap(exportDir.getBytes(UTF_8)));
-
     Map<String,String> opts = Collections.emptyMap();
 
     try {
@@ -1645,6 +1732,9 @@ public class TableOperationsImpl extends TableOperationsHelper {
     checkArgument(tableName != null, "tableName is null");
     checkArgument(className != null, "className is null");
     checkArgument(asTypeName != null, "asTypeName is null");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     try {
       return ServerClient.executeRaw(context,
@@ -1709,6 +1799,10 @@ public class TableOperationsImpl extends TableOperationsHelper {
 
   private void clearSamplerOptions(String tableName)
       throws AccumuloException, TableNotFoundException, AccumuloSecurityException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     String prefix = Property.TABLE_SAMPLER_OPTS.getKey();
     for (Entry<String,String> entry : getProperties(tableName)) {
       String property = entry.getKey();
@@ -1721,8 +1815,11 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public void setSamplerConfiguration(String tableName, SamplerConfiguration samplerConfiguration)
       throws AccumuloException, TableNotFoundException, AccumuloSecurityException {
-    clearSamplerOptions(tableName);
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
+    clearSamplerOptions(tableName);
     List<Pair<String,String>> props =
         new SamplerConfigurationImpl(samplerConfiguration).toTableProperties();
     for (Pair<String,String> pair : props) {
@@ -1733,6 +1830,10 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public void clearSamplerConfiguration(String tableName)
       throws AccumuloException, TableNotFoundException, AccumuloSecurityException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     removeProperty(tableName, Property.TABLE_SAMPLER.getKey());
     clearSamplerOptions(tableName);
   }
@@ -1740,6 +1841,10 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public SamplerConfiguration getSamplerConfiguration(String tableName)
       throws TableNotFoundException, AccumuloException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     AccumuloConfiguration conf = new ConfigurationCopy(this.getProperties(tableName));
     SamplerConfigurationImpl sci = SamplerConfigurationImpl.newSamplerConfig(conf);
     if (sci == null) {
@@ -1810,6 +1915,9 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public Locations locate(String tableName, Collection<Range> ranges)
       throws AccumuloException, AccumuloSecurityException, TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
     requireNonNull(tableName, "tableName must be non null");
     requireNonNull(ranges, "ranges must be non null");
 
@@ -1854,9 +1962,11 @@ public class TableOperationsImpl extends TableOperationsHelper {
 
   @Override
   public SummaryRetriever summaries(String tableName) {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
 
     return new SummaryRetriever() {
-
       private Text startRow = null;
       private Text endRow = null;
       private List<TSummarizerConfiguration> summariesToFetch = Collections.emptyList();
@@ -1957,12 +2067,15 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public void addSummarizers(String tableName, SummarizerConfiguration... newConfigs)
       throws AccumuloException, AccumuloSecurityException, TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     HashSet<SummarizerConfiguration> currentConfigs =
         new HashSet<>(SummarizerConfiguration.fromTableProperties(getProperties(tableName)));
     HashSet<SummarizerConfiguration> newConfigSet = new HashSet<>(Arrays.asList(newConfigs));
 
     newConfigSet.removeIf(currentConfigs::contains);
-
     Set<String> newIds =
         newConfigSet.stream().map(SummarizerConfiguration::getPropertyId).collect(toSet());
 
@@ -1982,8 +2095,13 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public void removeSummarizers(String tableName, Predicate<SummarizerConfiguration> predicate)
       throws AccumuloException, TableNotFoundException, AccumuloSecurityException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     Collection<SummarizerConfiguration> summarizerConfigs =
         SummarizerConfiguration.fromTableProperties(getProperties(tableName));
+
     for (SummarizerConfiguration sc : summarizerConfigs) {
       if (predicate.test(sc)) {
         Set<String> ks = sc.toTableProperties().keySet();
@@ -1997,6 +2115,10 @@ public class TableOperationsImpl extends TableOperationsHelper {
   @Override
   public List<SummarizerConfiguration> listSummarizers(String tableName)
       throws AccumuloException, TableNotFoundException {
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "tableName must only contain word characters (letters, digits, and underscores)"
+            + " and cannot exceed 1024 characters");
+
     return new ArrayList<>(SummarizerConfiguration.fromTableProperties(getProperties(tableName)));
   }
 
diff --git a/core/src/main/java/org/apache/accumulo/core/clientImpl/Tables.java b/core/src/main/java/org/apache/accumulo/core/clientImpl/Tables.java
index 35f68ad..e49efb8 100644
--- a/core/src/main/java/org/apache/accumulo/core/clientImpl/Tables.java
+++ b/core/src/main/java/org/apache/accumulo/core/clientImpl/Tables.java
@@ -45,12 +45,12 @@ import com.google.common.cache.CacheBuilder;
 
 public class Tables {
 
-  public static final String VALID_NAME_REGEX = "^(\\w+\\.)?(\\w+)$";
+  public static final String VALID_TABLENAME_REGEX = "^(\\w{1,1024}[.])?(\\w{1,1024})$";
 
   private static final SecurityPermission TABLES_PERMISSION =
       new SecurityPermission("tablesPermission");
-  // Per instance cache will expire after 10 minutes in case we encounter an instance not used
-  // frequently
+  // Per instance cache will expire after 10 minutes in case we
+  // encounter an instance not used frequently
   private static Cache<String,TableMap> instanceToMapCache =
       CacheBuilder.newBuilder().expireAfterAccess(10, TimeUnit.MINUTES).build();
 
@@ -114,9 +114,10 @@ public class Tables {
   public static TableId _getTableId(ClientContext context, String tableName)
       throws NamespaceNotFoundException, TableNotFoundException {
     TableId tableId = getNameToIdMap(context).get(tableName);
+
     if (tableId == null) {
-      // maybe the table exist, but the cache was not updated yet... so try to clear the cache and
-      // check again
+      // maybe the table exist, but the cache was not updated yet...
+      // so try to clear the cache and check again
       clearCache(context);
       tableId = getNameToIdMap(context).get(tableName);
       if (tableId == null) {
@@ -133,6 +134,7 @@ public class Tables {
   public static String getTableName(ClientContext context, TableId tableId)
       throws TableNotFoundException {
     String tableName = getIdToNameMap(context).get(tableId);
+
     if (tableName == null)
       throw new TableNotFoundException(tableId.canonical(), null, null);
     return tableName;
@@ -141,6 +143,7 @@ public class Tables {
   public static String getTableOfflineMsg(ClientContext context, TableId tableId) {
     if (tableId == null)
       return "Table <unknown table> is offline";
+
     try {
       String tableName = Tables.getTableName(context, tableId);
       return "Table " + tableName + " (" + tableId.canonical() + ") is offline";
@@ -163,9 +166,7 @@ public class Tables {
    */
   private static TableMap getTableMap(final ClientContext context) {
     TableMap map;
-
     final ZooCache zc = getZooCache(context);
-
     map = getTableMap(context, zc);
 
     if (!map.isCurrent(zc)) {
@@ -212,6 +213,7 @@ public class Tables {
 
   public static String getPrintableTableInfoFromId(ClientContext context, TableId tableId) {
     String tableName = null;
+
     try {
       tableName = getTableName(context, tableId);
     } catch (TableNotFoundException e) {
@@ -223,6 +225,7 @@ public class Tables {
 
   public static String getPrintableTableInfoFromName(ClientContext context, String tableName) {
     TableId tableId = null;
+
     try {
       tableId = getTableId(context, tableName);
     } catch (TableNotFoundException e) {
@@ -250,7 +253,6 @@ public class Tables {
    */
   public static TableState getTableState(ClientContext context, TableId tableId,
       boolean clearCachedState) {
-
     String statePath = context.getZooKeeperRoot() + Constants.ZTABLES + "/" + tableId.canonical()
         + Constants.ZTABLE_STATE;
 
@@ -273,6 +275,7 @@ public class Tables {
 
   public static String qualified(String tableName, String defaultNamespace) {
     Pair<String,String> qualifiedTableName = qualify(tableName, defaultNamespace);
+
     if (Namespace.DEFAULT.name().equals(qualifiedTableName.getFirst()))
       return qualifiedTableName.getSecond();
     else
@@ -284,8 +287,9 @@ public class Tables {
   }
 
   public static Pair<String,String> qualify(String tableName, String defaultNamespace) {
-    if (!tableName.matches(VALID_NAME_REGEX))
-      throw new IllegalArgumentException("Invalid table name '" + tableName + "'");
+    checkArgument(tableName.matches(VALID_TABLENAME_REGEX),
+        "Invalid table name '" + tableName + "'");
+
     if (MetadataTable.OLD_NAME.equals(tableName))
       tableName = MetadataTable.NAME;
     if (tableName.contains(".")) {
diff --git a/server/manager/src/main/java/org/apache/accumulo/manager/FateServiceHandler.java b/server/manager/src/main/java/org/apache/accumulo/manager/FateServiceHandler.java
index 36af428..8cf1f12 100644
--- a/server/manager/src/main/java/org/apache/accumulo/manager/FateServiceHandler.java
+++ b/server/manager/src/main/java/org/apache/accumulo/manager/FateServiceHandler.java
@@ -19,8 +19,6 @@
 package org.apache.accumulo.manager;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.apache.accumulo.core.Constants.MAX_NAMESPACE_LEN;
-import static org.apache.accumulo.core.Constants.MAX_TABLE_NAME_LEN;
 import static org.apache.accumulo.manager.util.TableValidators.CAN_CLONE;
 import static org.apache.accumulo.manager.util.TableValidators.NOT_METADATA;
 import static org.apache.accumulo.manager.util.TableValidators.NOT_ROOT_ID;
@@ -93,6 +91,8 @@ class FateServiceHandler implements FateService.Iface {
 
   protected final Manager manager;
   protected static final Logger log = Manager.log;
+  protected static final int MAX_TABLE_NAME_LEN = 1024;
+  protected static final int MAX_NAMESPACE_LEN = 1024;
 
   public FateServiceHandler(Manager manager) {
     this.manager = manager;
diff --git a/server/manager/src/main/java/org/apache/accumulo/manager/util/TableValidators.java b/server/manager/src/main/java/org/apache/accumulo/manager/util/TableValidators.java
index f0d39e4..4eefa80 100644
--- a/server/manager/src/main/java/org/apache/accumulo/manager/util/TableValidators.java
+++ b/server/manager/src/main/java/org/apache/accumulo/manager/util/TableValidators.java
@@ -18,7 +18,7 @@
  */
 package org.apache.accumulo.manager.util;
 
-import static org.apache.accumulo.core.clientImpl.Tables.VALID_NAME_REGEX;
+import static org.apache.accumulo.core.clientImpl.Tables.VALID_TABLENAME_REGEX;
 import static org.apache.accumulo.core.clientImpl.Tables.qualify;
 
 import java.util.Arrays;
@@ -39,7 +39,7 @@ public class TableValidators {
   public static final Validator<String> VALID_NAME = new Validator<>() {
     @Override
     public boolean test(String tableName) {
-      return tableName != null && tableName.matches(VALID_NAME_REGEX);
+      return tableName != null && tableName.matches(VALID_TABLENAME_REGEX);
     }
 
     @Override
diff --git a/shell/src/main/java/org/apache/accumulo/shell/commands/CreateTableCommand.java b/shell/src/main/java/org/apache/accumulo/shell/commands/CreateTableCommand.java
index 41d8c2c..93a933c 100644
--- a/shell/src/main/java/org/apache/accumulo/shell/commands/CreateTableCommand.java
+++ b/shell/src/main/java/org/apache/accumulo/shell/commands/CreateTableCommand.java
@@ -74,7 +74,7 @@ public class CreateTableCommand extends Command {
     final String testTableName = cl.getArgs()[0];
     NewTableConfiguration ntc = new NewTableConfiguration();
 
-    if (!testTableName.matches(Tables.VALID_NAME_REGEX)) {
+    if (!testTableName.matches(Tables.VALID_TABLENAME_REGEX)) {
       shellState.getWriter()
           .println("Only letters, numbers and underscores are allowed for use in table names.");
       throw new IllegalArgumentException();
diff --git a/test/src/main/java/org/apache/accumulo/test/NamespacesIT.java b/test/src/main/java/org/apache/accumulo/test/NamespacesIT.java
index b1d55df..d37dca3 100644
--- a/test/src/main/java/org/apache/accumulo/test/NamespacesIT.java
+++ b/test/src/main/java/org/apache/accumulo/test/NamespacesIT.java
@@ -18,7 +18,6 @@
  */
 package org.apache.accumulo.test;
 
-import static org.apache.accumulo.core.Constants.MAX_NAMESPACE_LEN;
 import static org.apache.accumulo.fate.util.UtilWaitThread.sleepUninterruptibly;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
@@ -100,6 +99,7 @@ public class NamespacesIT extends SharedMiniClusterBase {
 
   private AccumuloClient c;
   private String namespace;
+  private static final int MAX_NAMESPACE_LEN = 1024;
 
   @BeforeClass
   public static void setup() throws Exception {
diff --git a/test/src/main/java/org/apache/accumulo/test/TableOperationsIT.java b/test/src/main/java/org/apache/accumulo/test/TableOperationsIT.java
index 3182e35..884f121 100644
--- a/test/src/main/java/org/apache/accumulo/test/TableOperationsIT.java
+++ b/test/src/main/java/org/apache/accumulo/test/TableOperationsIT.java
@@ -18,7 +18,6 @@
  */
 package org.apache.accumulo.test;
 
-import static org.apache.accumulo.core.Constants.MAX_TABLE_NAME_LEN;
 import static org.apache.accumulo.fate.util.UtilWaitThread.sleepUninterruptibly;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
@@ -74,6 +73,7 @@ import com.google.common.collect.Sets;
 public class TableOperationsIT extends AccumuloClusterHarness {
 
   private AccumuloClient accumuloClient;
+  private static final int MAX_TABLE_NAME_LEN = 1024;
 
   @Override
   public int defaultTimeoutSeconds() {

Mime
View raw message