accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mmil...@apache.org
Subject [accumulo] 01/01: Merge branch '1.8'
Date Wed, 31 Jan 2018 00:08:25 GMT
This is an automated email from the ASF dual-hosted git repository.

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

commit 0cb58c519cb058d6a1029f2fe39f6071ca6b5ab8
Merge: 19f819d d6d8a7d
Author: Mike Miller <mmiller@apache.org>
AuthorDate: Tue Jan 30 19:02:46 2018 -0500

    Merge branch '1.8'
    
     Conflicts:
    	core/src/main/java/org/apache/accumulo/core/client/impl/MultiTableBatchWriterImpl.java
    	core/src/main/java/org/apache/accumulo/core/client/impl/Tables.java

 .../client/impl/MultiTableBatchWriterImpl.java     |  76 +--------
 .../apache/accumulo/core/client/impl/TableMap.java | 101 ++++++++++++
 .../apache/accumulo/core/client/impl/Tables.java   | 174 ++++++++-------------
 .../server/util/VerifyTabletAssignments.java       |   2 +-
 .../org/apache/accumulo/master/tableOps/Utils.java |   2 +-
 .../accumulo/test/MultiTableBatchWriterIT.java     | 119 +-------------
 6 files changed, 173 insertions(+), 301 deletions(-)

diff --cc core/src/main/java/org/apache/accumulo/core/client/impl/MultiTableBatchWriterImpl.java
index aa0d469,a4a5b2f..255aa01
--- a/core/src/main/java/org/apache/accumulo/core/client/impl/MultiTableBatchWriterImpl.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/impl/MultiTableBatchWriterImpl.java
@@@ -82,37 -71,13 +71,13 @@@ public class MultiTableBatchWriterImpl 
  
    }
  
-   /**
-    * CacheLoader which will look up the internal table ID for a given table name.
-    */
-   private class TableNameToIdLoader extends CacheLoader<String,Table.ID> {
- 
-     @Override
-     public Table.ID load(String tableName) throws Exception {
-       Instance instance = context.getInstance();
-       Table.ID tableId = Tables.getTableId(instance, tableName);
- 
-       if (Tables.getTableState(instance, tableId) == TableState.OFFLINE)
-         throw new TableOfflineException(instance, tableId.canonicalID());
- 
-       return tableId;
-     }
- 
-   }
- 
    private TabletServerBatchWriter bw;
 -  private ConcurrentHashMap<String,BatchWriter> tableWriters;
 +  private ConcurrentHashMap<Table.ID,BatchWriter> tableWriters;
    private final ClientContext context;
-   private final LoadingCache<String,Table.ID> nameToIdCache;
  
    public MultiTableBatchWriterImpl(ClientContext context, BatchWriterConfig config) {
-     this(context, config, DEFAULT_CACHE_TIME, DEFAULT_CACHE_TIME_UNIT);
-   }
- 
-   public MultiTableBatchWriterImpl(ClientContext context, BatchWriterConfig config, long
cacheTime, TimeUnit cacheTimeUnit) {
      checkArgument(context != null, "context is null");
      checkArgument(config != null, "config is null");
-     checkArgument(cacheTimeUnit != null, "cacheTimeUnit is null");
      this.context = context;
      this.bw = new TabletServerBatchWriter(context, config);
      tableWriters = new ConcurrentHashMap<>();
@@@ -156,9 -116,9 +116,9 @@@
     *          The name of the table which to find the ID for
     * @return The table ID, or null if the table name doesn't exist
     */
 -  private String getId(String tableName) throws TableNotFoundException {
 +  private Table.ID getId(String tableName) throws TableNotFoundException {
      try {
-       return nameToIdCache.get(tableName);
+       return Tables.getTableId(context.inst, tableName);
      } catch (UncheckedExecutionException e) {
        Throwable cause = e.getCause();
  
@@@ -194,27 -140,7 +140,7 @@@
    public BatchWriter getBatchWriter(String tableName) throws AccumuloException, AccumuloSecurityException,
TableNotFoundException {
      checkArgument(tableName != null, "tableName is null");
  
-     while (true) {
-       long cacheResetCount = Tables.getCacheResetCount();
- 
-       // cacheResetCount could change after this point in time, but I think thats ok because
just want to ensure this methods sees changes
-       // made before it was called.
- 
-       long internalResetCount = cacheLastState.get();
- 
-       if (cacheResetCount > internalResetCount) {
-         if (!cacheLastState.compareAndSet(internalResetCount, cacheResetCount)) {
-           continue; // concurrent operation, lets not possibly move cacheLastState backwards
in the case where a thread pauses for along time
-         }
- 
-         nameToIdCache.invalidateAll();
-         break;
-       }
- 
-       break;
-     }
- 
 -    String tableId = getId(tableName);
 +    Table.ID tableId = getId(tableName);
  
      BatchWriter tbw = tableWriters.get(tableId);
      if (tbw == null) {
diff --cc core/src/main/java/org/apache/accumulo/core/client/impl/TableMap.java
index 0000000,3f3d90c..9f17fde
mode 000000,100644..100644
--- a/core/src/main/java/org/apache/accumulo/core/client/impl/TableMap.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/impl/TableMap.java
@@@ -1,0 -1,100 +1,101 @@@
+ /*
+  * 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.impl;
+ 
+ import static java.nio.charset.StandardCharsets.UTF_8;
+ import static org.apache.accumulo.core.client.impl.Tables.qualified;
+ 
+ import java.util.HashMap;
+ import java.util.List;
+ import java.util.Map;
+ 
+ import org.apache.accumulo.core.Constants;
+ import org.apache.accumulo.core.client.Instance;
+ import org.apache.accumulo.core.client.NamespaceNotFoundException;
+ import org.apache.accumulo.core.zookeeper.ZooUtil;
+ import org.apache.accumulo.fate.zookeeper.ZooCache;
+ import org.slf4j.Logger;
+ import org.slf4j.LoggerFactory;
+ 
+ import com.google.common.collect.ImmutableMap;
+ 
+ /**
+  * Used for thread safe caching of immutable table ID maps. See ACCUMULO-4778.
+  */
+ public class TableMap {
+   private static final Logger log = LoggerFactory.getLogger(TableMap.class);
+ 
 -  private final Map<String,String> tableNameToIdMap;
 -  private final Map<String,String> tableIdToNameMap;
++  private final Map<String,Table.ID> tableNameToIdMap;
++  private final Map<Table.ID,String> tableIdToNameMap;
+ 
+   public TableMap(Instance instance, ZooCache zooCache) {
+     List<String> tableIds = zooCache.getChildren(ZooUtil.getRoot(instance) + Constants.ZTABLES);
 -    Map<String,String> namespaceIdToNameMap = new HashMap<>();
 -    ImmutableMap.Builder<String,String> tableNameToIdBuilder = new ImmutableMap.Builder<>();
 -    ImmutableMap.Builder<String,String> tableIdToNameBuilder = new ImmutableMap.Builder<>();
++    Map<Namespace.ID,String> namespaceIdToNameMap = new HashMap<>();
++    ImmutableMap.Builder<String,Table.ID> tableNameToIdBuilder = new ImmutableMap.Builder<>();
++    ImmutableMap.Builder<Table.ID,String> tableIdToNameBuilder = new ImmutableMap.Builder<>();
+     // use StringBuilder to construct zPath string efficiently across many tables
+     StringBuilder zPathBuilder = new StringBuilder();
+     zPathBuilder.append(ZooUtil.getRoot(instance)).append(Constants.ZTABLES).append("/");
+     int prefixLength = zPathBuilder.length();
+ 
 -    for (String tableId : tableIds) {
++    for (String tableIdStr : tableIds) {
+       // reset StringBuilder to prefix length before appending ID and suffix
+       zPathBuilder.setLength(prefixLength);
 -      zPathBuilder.append(tableId).append(Constants.ZTABLE_NAME);
++      zPathBuilder.append(tableIdStr).append(Constants.ZTABLE_NAME);
+       byte[] tableName = zooCache.get(zPathBuilder.toString());
+       zPathBuilder.setLength(prefixLength);
 -      zPathBuilder.append(tableId).append(Constants.ZTABLE_NAMESPACE);
++      zPathBuilder.append(tableIdStr).append(Constants.ZTABLE_NAMESPACE);
+       byte[] nId = zooCache.get(zPathBuilder.toString());
+ 
 -      String namespaceName = Namespaces.DEFAULT_NAMESPACE;
++      String namespaceName = Namespace.DEFAULT;
+       // create fully qualified table name
+       if (nId == null) {
+         namespaceName = null;
+       } else {
 -        String namespaceId = new String(nId, UTF_8);
 -        if (!namespaceId.equals(Namespaces.DEFAULT_NAMESPACE_ID)) {
++        Namespace.ID namespaceId = Namespace.ID.of(new String(nId, UTF_8));
++        if (!namespaceId.equals(Namespace.ID.DEFAULT)) {
+           try {
+             namespaceName = namespaceIdToNameMap.get(namespaceId);
+             if (namespaceName == null) {
+               namespaceName = Namespaces.getNamespaceName(instance, namespaceId);
+               namespaceIdToNameMap.put(namespaceId, namespaceName);
+             }
+           } catch (NamespaceNotFoundException e) {
 -            log.error("Table (" + tableId + ") contains reference to namespace (" + namespaceId
+ ") that doesn't exist", e);
++            log.error("Table (" + tableIdStr + ") contains reference to namespace (" + namespaceId
+ ") that doesn't exist", e);
+             continue;
+           }
+         }
+       }
+       if (tableName != null && namespaceName != null) {
+         String tableNameStr = qualified(new String(tableName, UTF_8), namespaceName);
++        Table.ID tableId = Table.ID.of(tableIdStr);
+         tableNameToIdBuilder.put(tableNameStr, tableId);
+         tableIdToNameBuilder.put(tableId, tableNameStr);
+       }
+     }
+     tableNameToIdMap = tableNameToIdBuilder.build();
+     tableIdToNameMap = tableIdToNameBuilder.build();
+   }
+ 
 -  public Map<String,String> getNameToIdMap() {
++  public Map<String,Table.ID> getNameToIdMap() {
+     return tableNameToIdMap;
+   }
+ 
 -  public Map<String,String> getIdtoNameMap() {
++  public Map<Table.ID,String> getIdtoNameMap() {
+     return tableIdToNameMap;
+   }
+ }
diff --cc core/src/main/java/org/apache/accumulo/core/client/impl/Tables.java
index 512c875,a93347c..94bd193
--- a/core/src/main/java/org/apache/accumulo/core/client/impl/Tables.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/impl/Tables.java
@@@ -19,14 -19,12 +19,11 @@@ package org.apache.accumulo.core.client
  import static com.google.common.base.Preconditions.checkArgument;
  import static java.nio.charset.StandardCharsets.UTF_8;
  
- import java.util.ArrayList;
- import java.util.HashMap;
+ import java.security.SecurityPermission;
  import java.util.List;
  import java.util.Map;
- import java.util.SortedMap;
- import java.util.TreeMap;
- import java.util.concurrent.atomic.AtomicLong;
- import java.util.function.BiConsumer;
 -import java.util.concurrent.Callable;
+ import java.util.concurrent.ExecutionException;
+ import java.util.concurrent.TimeUnit;
  
  import org.apache.accumulo.core.Constants;
  import org.apache.accumulo.core.client.Instance;
@@@ -38,37 -36,61 +35,57 @@@ import org.apache.accumulo.core.util.Pa
  import org.apache.accumulo.core.zookeeper.ZooUtil;
  import org.apache.accumulo.fate.zookeeper.ZooCache;
  import org.apache.accumulo.fate.zookeeper.ZooCacheFactory;
- import org.slf4j.Logger;
- import org.slf4j.LoggerFactory;
 -import org.apache.zookeeper.WatchedEvent;
 -import org.apache.zookeeper.Watcher;
+ 
+ import com.google.common.cache.Cache;
+ import com.google.common.cache.CacheBuilder;
  
  public class Tables {
-   private static final Logger log = LoggerFactory.getLogger(Tables.class);
  
    public static final String VALID_NAME_REGEX = "^(\\w+\\.)?(\\w+)$";
  
-   private static final AtomicLong cacheResetCount = new AtomicLong(0);
- 
-   private static ZooCache getZooCache(Instance instance) {
-     return new ZooCacheFactory().getZooCache(instance.getZooKeepers(), instance.getZooKeepersSessionTimeOut());
-   }
+   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
+   private static Cache<String,TableMap> instanceToMapCache = CacheBuilder.newBuilder().expireAfterAccess(10,
TimeUnit.MINUTES).build();
+   private static Cache<String,ZooCache> instanceToZooCache = CacheBuilder.newBuilder().expireAfterAccess(10,
TimeUnit.MINUTES).build();
  
    /**
 +   * Lookup table ID in ZK. Throw TableNotFoundException if not found. Also wraps NamespaceNotFoundException
in TableNotFoundException if namespace is not
 +   * found.
 +   */
 +  public static Table.ID getTableId(Instance instance, String tableName) throws TableNotFoundException
{
 +    try {
 +      return _getTableId(instance, tableName);
 +    } catch (NamespaceNotFoundException e) {
 +      throw new TableNotFoundException(tableName, e);
 +    }
 +  }
 +
 +  /**
+    * Return the cached ZooCache for provided instance. ZooCache is initially created with
a watcher that will clear the TableMap cache for that instance when
+    * WatchedEvent occurs.
+    */
+   private static ZooCache getZooCache(final Instance instance) {
+     SecurityManager sm = System.getSecurityManager();
+     if (sm != null) {
+       sm.checkPermission(TABLES_PERMISSION);
+     }
+     final String zks = instance.getZooKeepers();
+     final int timeOut = instance.getZooKeepersSessionTimeOut();
+     final String uuid = instance.getInstanceID();
+ 
+     try {
 -      return instanceToZooCache.get(uuid, new Callable<ZooCache>() {
 -        @Override
 -        public ZooCache call() {
 -          return new ZooCacheFactory().getZooCache(zks, timeOut, new Watcher() {
 -            @Override
 -            public void process(WatchedEvent watchedEvent) {
 -              instanceToMapCache.invalidate(uuid);
 -            }
 -          });
 -        }
 -      });
++      return instanceToZooCache.get(uuid, () -> new ZooCacheFactory().getZooCache(zks,
timeOut,
++              watchedEvent -> instanceToMapCache.invalidate(uuid)));
+     } catch (ExecutionException e) {
+       throw new RuntimeException(e);
+     }
+   }
+ 
 -  public static String getTableId(Instance instance, String tableName) throws TableNotFoundException
{
 -    try {
 -      return _getTableId(instance, tableName);
 -    } catch (NamespaceNotFoundException e) {
 -      throw new TableNotFoundException(tableName, e);
 -    }
 -  }
 -
 -  public static String _getTableId(Instance instance, String tableName) throws NamespaceNotFoundException,
TableNotFoundException {
 -    String tableId = getNameToIdMap(instance).get(tableName);
++  /**
 +   * Lookup table ID in ZK. If not found, clears cache and tries again.
 +   */
 +  public static Table.ID _getTableId(Instance instance, String tableName) throws NamespaceNotFoundException,
TableNotFoundException {
-     Table.ID tableId = lookupTableId(instance, tableName);
++    Table.ID tableId = getNameToIdMap(instance).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
        clearCache(instance);
@@@ -84,12 -106,44 +101,39 @@@
      return tableId;
    }
  
 -  public static String getTableName(Instance instance, String tableId) throws TableNotFoundException
{
++  public static String getTableName(Instance instance, Table.ID tableId) throws TableNotFoundException
{
+     String tableName = getIdToNameMap(instance).get(tableId);
+     if (tableName == null)
 -      throw new TableNotFoundException(tableId, null, null);
++      throw new TableNotFoundException(tableId.canonicalID(), null, null);
+     return tableName;
+   }
+ 
 -  public static Map<String,String> getNameToIdMap(Instance instance) {
++  public static Map<String,Table.ID> getNameToIdMap(Instance instance) {
+     return getTableMap(instance).getNameToIdMap();
+   }
+ 
 -  public static Map<String,String> getIdToNameMap(Instance instance) {
++  public static Map<Table.ID,String> getIdToNameMap(Instance instance) {
+     return getTableMap(instance).getIdtoNameMap();
+   }
+ 
+   /**
+    * Get the TableMap from the cache. A new one will be populated when needed. Cache is
cleared manually by calling {@link #clearCache(Instance)} or
+    * automatically cleared by ZooCache watcher created in {@link #getZooCache(Instance)}.
See ACCUMULO-4778.
+    */
+   private static TableMap getTableMap(final Instance instance) {
+     TableMap map;
+     try {
 -      map = instanceToMapCache.get(instance.getInstanceID(), new Callable<TableMap>()
{
 -        @Override
 -        public TableMap call() {
 -          return new TableMap(instance, getZooCache(instance));
 -        }
 -      });
++      map = instanceToMapCache.get(instance.getInstanceID(), () -> new TableMap(instance,
getZooCache(instance)));
+     } catch (ExecutionException e) {
+       throw new RuntimeException(e);
+     }
+     return map;
+   }
+ 
 -  public static boolean exists(Instance instance, String tableId) {
 +  public static boolean exists(Instance instance, Table.ID tableId) {
-     if (tableId == null)
-       return false;
      ZooCache zc = getZooCache(instance);
      List<String> tableIds = zc.getChildren(ZooUtil.getRoot(instance) + Constants.ZTABLES);
 -    return tableIds.contains(tableId);
 +    return tableIds.contains(tableId.canonicalID());
    }
  
    public static void clearCache(Instance instance) {
@@@ -107,20 -161,17 +151,12 @@@
     *          A zookeeper path
     */
    public static void clearCacheByPath(Instance instance, final String zooPath) {
- 
-     String thePath;
- 
-     if (zooPath.startsWith("/")) {
-       thePath = zooPath;
-     } else {
-       thePath = "/" + zooPath;
-     }
- 
+     String thePath = zooPath.startsWith("/") ? zooPath : "/" + zooPath;
      getZooCache(instance).clear(ZooUtil.getRoot(instance) + thePath);
- 
+     instanceToMapCache.invalidate(instance.getInstanceID());
    }
  
 -  public static String getPrintableTableNameFromId(Map<String,String> tidToNameMap,
String tableId) {
 -    String tableName = tidToNameMap.get(tableId);
 -    return tableName == null ? "(ID:" + tableId + ")" : tableName;
 -  }
 -
 -  public static String getPrintableTableInfoFromId(Instance instance, String tableId) {
 +  public static String getPrintableTableInfoFromId(Instance instance, Table.ID tableId)
{
      String tableName = null;
      try {
        tableName = getTableName(instance, tableId);
@@@ -173,12 -224,8 +209,8 @@@
  
    }
  
-   public static long getCacheResetCount() {
-     return cacheResetCount.get();
-   }
- 
    public static String qualified(String tableName) {
 -    return qualified(tableName, Namespaces.DEFAULT_NAMESPACE);
 +    return qualified(tableName, Namespace.DEFAULT);
    }
  
    public static String qualified(String tableName, String defaultNamespace) {
@@@ -225,85 -272,10 +257,9 @@@
  
      // We might get null out of ZooCache if this tableID doesn't exist
      if (null == n) {
 -      throw new TableNotFoundException(tableId, null, null);
 +      throw new TableNotFoundException(tableId.canonicalID(), null, null);
      }
  
 -    return new String(n, UTF_8);
 +    return Namespace.ID.of(new String(n, UTF_8));
    }
- 
-   /**
-    * Get all table Ids and table names from ZK. The biConsumer accepts the first arg (t)
as the table ID and second arg (u) as the table name.
-    */
-   private static void getAllTables(Instance instance, BiConsumer<String,String> biConsumer)
{
-     ZooCache zc = getZooCache(instance);
-     List<String> tableIds = zc.getChildren(ZooUtil.getRoot(instance) + Constants.ZTABLES);
-     Map<Namespace.ID,String> namespaceIdToNameMap = new HashMap<>();
- 
-     for (String tableId : tableIds) {
-       byte[] tableName = zc.get(ZooUtil.getRoot(instance) + Constants.ZTABLES + "/" + tableId
+ Constants.ZTABLE_NAME);
-       byte[] nId = zc.get(ZooUtil.getRoot(instance) + Constants.ZTABLES + "/" + tableId
+ Constants.ZTABLE_NAMESPACE);
-       String namespaceName = Namespace.DEFAULT;
-       // create fully qualified table name
-       if (nId == null) {
-         namespaceName = null;
-       } else {
-         Namespace.ID namespaceId = Namespace.ID.of(new String(nId, UTF_8));
-         if (!namespaceId.equals(Namespace.ID.DEFAULT)) {
-           try {
-             namespaceName = namespaceIdToNameMap.get(namespaceId);
-             if (namespaceName == null) {
-               namespaceName = Namespaces.getNamespaceName(instance, namespaceId);
-               namespaceIdToNameMap.put(namespaceId, namespaceName);
-             }
-           } catch (NamespaceNotFoundException e) {
-             log.error("Table (" + tableId + ") contains reference to namespace (" + namespaceId
+ ") that doesn't exist", e);
-             continue;
-           }
-         }
-       }
-       if (tableName != null && namespaceName != null) {
-         String tableNameStr = qualified(new String(tableName, UTF_8), namespaceName);
-         biConsumer.accept(tableId, tableNameStr);
-       }
-     }
-   }
- 
-   public static SortedMap<Table.ID,String> getIdToNameMap(Instance instance) {
-     SortedMap<Table.ID,String> map = new TreeMap<>();
-     getAllTables(instance, (id, name) -> map.put(Table.ID.of(id), name));
-     return map;
-   }
- 
-   public static SortedMap<String,Table.ID> getNameToIdMap(Instance instance) {
-     SortedMap<String,Table.ID> map = new TreeMap<>();
-     getAllTables(instance, (id, name) -> map.put(name, Table.ID.of(id)));
-     return map;
-   }
- 
-   /**
-    * Lookup the table name in ZK. Fail quietly, returning null if not found.
-    */
-   public static Table.ID lookupTableId(Instance instance, String tableName) {
-     ArrayList<Table.ID> singleId = new ArrayList<>(1);
-     getAllTables(instance, (id, name) -> {
-       if (name.equals(tableName))
-         singleId.add(Table.ID.of(id));
-     });
-     if (singleId.isEmpty())
-       return null;
-     else
-       return singleId.get(0);
-   }
- 
-   public static String getTableName(Instance instance, Table.ID tableId) throws TableNotFoundException
{
-     ArrayList<String> singleName = new ArrayList<>(1);
-     getAllTables(instance, (id, name) -> {
-       if (id.equals(tableId.canonicalID()))
-         singleName.add(name);
-     });
-     if (singleName.isEmpty())
-       throw new TableNotFoundException(tableId.canonicalID(), null, null);
--
-     return singleName.get(0);
-   }
  }
diff --cc server/base/src/main/java/org/apache/accumulo/server/util/VerifyTabletAssignments.java
index cdf7e3c,198ab95..3ee943b
--- a/server/base/src/main/java/org/apache/accumulo/server/util/VerifyTabletAssignments.java
+++ b/server/base/src/main/java/org/apache/accumulo/server/util/VerifyTabletAssignments.java
@@@ -90,7 -89,7 +90,7 @@@ public class VerifyTabletAssignments 
  
      TreeMap<KeyExtent,String> tabletLocations = new TreeMap<>();
  
-     Table.ID tableId = Tables.lookupTableId(context.getInstance(), tableName);
 -    String tableId = Tables.getNameToIdMap(context.getInstance()).get(tableName);
++    Table.ID tableId = Tables.getNameToIdMap(context.getInstance()).get(tableName);
      MetadataServicer.forTableId(context, tableId).getTabletLocations(tabletLocations);
  
      final HashSet<KeyExtent> failures = new HashSet<>();
diff --cc server/master/src/main/java/org/apache/accumulo/master/tableOps/Utils.java
index 96e954e,f58c3ee..b1e2228
--- a/server/master/src/main/java/org/apache/accumulo/master/tableOps/Utils.java
+++ b/server/master/src/main/java/org/apache/accumulo/master/tableOps/Utils.java
@@@ -49,10 -46,10 +49,10 @@@ public class Utils 
    private static final byte[] ZERO_BYTE = new byte[] {'0'};
    private static final Logger log = LoggerFactory.getLogger(Utils.class);
  
 -  static void checkTableDoesNotExist(Instance instance, String tableName, String tableId,
TableOperation operation)
 +  static void checkTableDoesNotExist(Instance instance, String tableName, Table.ID tableId,
TableOperation operation)
        throws AcceptableThriftTableOperationException {
  
-     Table.ID id = Tables.lookupTableId(instance, tableName);
 -    String id = Tables.getNameToIdMap(instance).get(tableName);
++    Table.ID id = Tables.getNameToIdMap(instance).get(tableName);
  
      if (id != null && !id.equals(tableId))
        throw new AcceptableThriftTableOperationException(null, tableName, operation, TableOperationExceptionType.EXISTS,
null);

-- 
To stop receiving notification emails like this one, please contact
mmiller@apache.org.

Mime
View raw message