Merge remote-tracking branch 'upstream/elasticity' into importWithHostingGoal

# Conflicts:
#	server/manager/src/main/java/org/apache/accumulo/manager/FateServiceHandler.java
#	server/manager/src/main/java/org/apache/accumulo/manager/tableOps/tableImport/PopulateMetadataTable.java

Author: DomGarguilo

core/src/main/java/org/apache/accumulo/core/client/admin/HostingGoalForTablet.java core/src/main/java/org/apache/accumulo/core/client/admin/AvailabilityForTablet.java

@@ -23,23 +23,23 @@
 import org.apache.accumulo.core.data.TabletId;
 
 /**
- * This class contains information that defines the tablet hosting data for a table. The class
- * contains the TabletId and associated goal for each tablet in a table or a subset of tablets if a
- * range is provided.
+ * This class contains information that defines the tablet availability data for a table. The class
+ * contains the TabletId and associated availability for each tablet in a table or a subset of
+ * tablets if a range is provided.
  *
  * @since 4.0.0
  */
-public class HostingGoalForTablet {
+public class AvailabilityForTablet {
   private final TabletId tabletId;
-  private final TabletHostingGoal hostingGoal;
+  private final TabletAvailability tabletAvailability;
 
-  public HostingGoalForTablet(TabletId tabletId, TabletHostingGoal hostingGoal) {
+  public AvailabilityForTablet(TabletId tabletId, TabletAvailability tabletAvailability) {
     this.tabletId = tabletId;
-    this.hostingGoal = hostingGoal;
+    this.tabletAvailability = tabletAvailability;
   }
 
-  public TabletHostingGoal getHostingGoal() {
-    return hostingGoal;
+  public TabletAvailability getTabletAvailability() {
+    return tabletAvailability;
   }
 
   public TabletId getTabletId() {
@@ -54,12 +54,12 @@ public boolean equals(Object o) {
     if (o == null || getClass() != o.getClass()) {
       return false;
     }
-    HostingGoalForTablet that = (HostingGoalForTablet) o;
-    return Objects.equals(tabletId, that.tabletId) && hostingGoal == that.hostingGoal;
+    AvailabilityForTablet that = (AvailabilityForTablet) o;
+    return Objects.equals(tabletId, that.tabletId) && tabletAvailability == that.tabletAvailability;
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(tabletId, hostingGoal);
+    return Objects.hash(tabletId, tabletAvailability);
   }
 }

core/src/main/java/org/apache/accumulo/core/client/admin/NewTableConfiguration.java

@@ -72,7 +72,7 @@ public class NewTableConfiguration {
   private Map<String,String> localityProps = Collections.emptyMap();
   private final Map<String,String> iteratorProps = new HashMap<>();
   private SortedSet<Text> splitProps = Collections.emptySortedSet();
-  private TabletHostingGoal initialHostingGoal = TabletHostingGoal.ONDEMAND;
+  private TabletAvailability initialTabletAvailability = TabletAvailability.ONDEMAND;
 
   private void checkDisjoint(Map<String,String> props, Map<String,String> derivedProps,
       String kind) {
@@ -317,21 +317,22 @@ public NewTableConfiguration attachIterator(IteratorSetting setting,
   }
 
   /**
-   * Sets the initial tablet hosting goal for all tablets. If not set, the default is
-   * {@link TabletHostingGoal#ONDEMAND}
+   * Sets the initial tablet availability for all tablets. If not set, the default is
+   * {@link TabletAvailability#ONDEMAND}
    *
    * @since 4.0.0
    */
-  public NewTableConfiguration withInitialHostingGoal(final TabletHostingGoal goal) {
-    this.initialHostingGoal = goal;
+  public NewTableConfiguration
+      withInitialTabletAvailability(final TabletAvailability tabletAvailability) {
+    this.initialTabletAvailability = tabletAvailability;
     return this;
   }
 
   /**
    * @since 4.0.0
    */
-  public TabletHostingGoal getInitialHostingGoal() {
-    return this.initialHostingGoal;
+  public TabletAvailability getInitialTabletAvailability() {
+    return this.initialTabletAvailability;
   }
 
   /**

core/src/main/java/org/apache/accumulo/core/client/admin/TableOperations.java

@@ -1009,17 +1009,18 @@ default TimeType getTimeType(String tableName) throws TableNotFoundException {
   }
 
   /**
-   * Sets the hosting goal for a range of Tablets in the specified table, but does not wait for the
-   * tablets to reach this goal state. For the Range parameter, note that the Row portion of the
-   * start and end Keys and the inclusivity parameters are used when determining the range of
-   * affected tablets. The other portions of the start and end Keys are not used.
+   * Sets the tablet availability for a range of Tablets in the specified table, but does not wait
+   * for the tablets to reach this availability state. For the Range parameter, note that the Row
+   * portion of the start and end Keys and the inclusivity parameters are used when determining the
+   * range of affected tablets. The other portions of the start and end Keys are not used.
    *
    * @param tableName table name
    * @param range tablet range
-   * @param goal hosting goal
+   * @param tabletAvailability tablet availability
    * @since 4.0.0
    */
-  default void setTabletHostingGoal(String tableName, Range range, TabletHostingGoal goal)
+  default void setTabletAvailability(String tableName, Range range,
+      TabletAvailability tabletAvailability)
       throws AccumuloSecurityException, AccumuloException, TableNotFoundException {
     throw new UnsupportedOperationException();
   }

core/src/main/java/org/apache/accumulo/core/client/admin/TabletHostingGoal.java core/src/main/java/org/apache/accumulo/core/client/admin/TabletAvailability.java

@@ -19,19 +19,25 @@
 package org.apache.accumulo.core.client.admin;
 
 /**
- * @see TableOperations#setTabletHostingGoal(String, org.apache.accumulo.core.data.Range,
- *      TabletHostingGoal)
+ * @see TableOperations#setTabletAvailability(String, org.apache.accumulo.core.data.Range,
+ *      TabletAvailability)
  * @since 4.0.0
  */
-public enum TabletHostingGoal {
+public enum TabletAvailability {
 
-  // Signifies that a Tablet should always be hosted
-  ALWAYS,
+  /**
+   * Signifies that a Tablet should always be hosted on a tablet server.
+   */
+  HOSTED,
 
-  // Signifies that a Tablet should be hosted on client request
+  /**
+   * Signifies that a Tablet should be hosted on a tablet server when a client needs it.
+   */
   ONDEMAND,
 
-  // Signifies that a Tablet should never be hosted
-  NEVER;
+  /**
+   * Signifies that a Tablet should never be hosted on a tablet server.
+   */
+  UNHOSTED;
 
 }

core/src/main/java/org/apache/accumulo/core/client/admin/TabletInformation.java

@@ -69,8 +69,8 @@ public interface TabletInformation {
   String getTabletDir();
 
   /**
-   * @return the tablet hosting goal.
+   * @return the TabletAvailability object.
    */
-  TabletHostingGoal getHostingGoal();
+  TabletAvailability getTabletAvailability();
 
 }

core/src/main/java/org/apache/accumulo/core/clientImpl/ClientTabletCache.java

@@ -34,7 +34,7 @@
 import org.apache.accumulo.core.client.AccumuloSecurityException;
 import org.apache.accumulo.core.client.InvalidTabletHostingRequestException;
 import org.apache.accumulo.core.client.TableNotFoundException;
-import org.apache.accumulo.core.client.admin.TabletHostingGoal;
+import org.apache.accumulo.core.client.admin.TabletAvailability;
 import org.apache.accumulo.core.data.InstanceId;
 import org.apache.accumulo.core.data.Mutation;
 import org.apache.accumulo.core.data.Range;
@@ -52,7 +52,7 @@
 
 /**
  * Client side cache of information about Tablets. Currently, a tablet prev end row is cached and
- * locations are cached if they exists.
+ * locations are cached if they exist.
  */
 public abstract class ClientTabletCache {
 
@@ -308,39 +308,40 @@ public static class CachedTablet {
     private final KeyExtent tablet_extent;
     private final String tserverLocation;
     private final String tserverSession;
-    private final TabletHostingGoal goal;
+    private final TabletAvailability availability;
     private final boolean hostingRequested;
 
     private final Long creationTime = System.nanoTime();
 
     public CachedTablet(KeyExtent tablet_extent, String tablet_location, String session,
-        TabletHostingGoal goal, boolean hostingRequested) {
+        TabletAvailability availability, boolean hostingRequested) {
       checkArgument(tablet_extent != null, "tablet_extent is null");
       checkArgument(tablet_location != null, "tablet_location is null");
       checkArgument(session != null, "session is null");
       this.tablet_extent = tablet_extent;
       this.tserverLocation = interner.intern(tablet_location);
       this.tserverSession = interner.intern(session);
-      this.goal = Objects.requireNonNull(goal);
+      this.availability = Objects.requireNonNull(availability);
       this.hostingRequested = hostingRequested;
     }
 
     public CachedTablet(KeyExtent tablet_extent, Optional<String> tablet_location,
-        Optional<String> session, TabletHostingGoal goal, boolean hostingRequested) {
+        Optional<String> session, TabletAvailability availability, boolean hostingRequested) {
       checkArgument(tablet_extent != null, "tablet_extent is null");
       this.tablet_extent = tablet_extent;
       this.tserverLocation = tablet_location.map(interner::intern).orElse(null);
       this.tserverSession = session.map(interner::intern).orElse(null);
-      this.goal = Objects.requireNonNull(goal);
+      this.availability = Objects.requireNonNull(availability);
       this.hostingRequested = hostingRequested;
     }
 
-    public CachedTablet(KeyExtent tablet_extent, TabletHostingGoal goal, boolean hostingRequested) {
+    public CachedTablet(KeyExtent tablet_extent, TabletAvailability availability,
+        boolean hostingRequested) {
       checkArgument(tablet_extent != null, "tablet_extent is null");
       this.tablet_extent = tablet_extent;
       this.tserverLocation = null;
       this.tserverSession = null;
-      this.goal = Objects.requireNonNull(goal);
+      this.availability = Objects.requireNonNull(availability);
       this.hostingRequested = hostingRequested;
     }
 
@@ -350,21 +351,23 @@ public boolean equals(Object o) {
         CachedTablet otl = (CachedTablet) o;
         return getExtent().equals(otl.getExtent())
             && getTserverLocation().equals(otl.getTserverLocation())
-            && getTserverSession().equals(otl.getTserverSession()) && getGoal() == otl.getGoal()
+            && getTserverSession().equals(otl.getTserverSession())
+            && getAvailability() == otl.getAvailability()
             && hostingRequested == otl.hostingRequested;
       }
       return false;
     }
 
     @Override
     public int hashCode() {
-      return Objects.hash(getExtent(), tserverLocation, tserverSession, goal, hostingRequested);
+      return Objects.hash(getExtent(), tserverLocation, tserverSession, availability,
+          hostingRequested);
     }
 
     @Override
     public String toString() {
       return "(" + getExtent() + "," + getTserverLocation() + "," + getTserverSession() + ","
-          + getGoal() + ")";
+          + getAvailability() + ")";
     }
 
     public KeyExtent getExtent() {
@@ -381,12 +384,12 @@ public Optional<String> getTserverSession() {
 
     /**
      * The ClientTabletCache will remove and replace a CachedTablet when the location is no longer
-     * valid. However, it will not do the same when the goal is no longer valid. The goal returned
-     * by this method may be out of date. If this information is needed to be fresh, then you may
-     * want to consider clearing the cache first.
+     * valid. However, it will not do the same when the availability is no longer valid. The
+     * availability returned by this method may be out of date. If this information is needed to be
+     * fresh, then you may want to consider clearing the cache first.
      */
-    public TabletHostingGoal getGoal() {
-      return this.goal;
+    public TabletAvailability getAvailability() {
+      return this.availability;
     }
 
     public Duration getAge() {

core/src/main/java/org/apache/accumulo/core/clientImpl/ClientTabletCacheImpl.java

@@ -45,7 +45,7 @@
 import org.apache.accumulo.core.client.AccumuloSecurityException;
 import org.apache.accumulo.core.client.InvalidTabletHostingRequestException;
 import org.apache.accumulo.core.client.TableNotFoundException;
-import org.apache.accumulo.core.client.admin.TabletHostingGoal;
+import org.apache.accumulo.core.client.admin.TabletAvailability;
 import org.apache.accumulo.core.data.Key;
 import org.apache.accumulo.core.data.Mutation;
 import org.apache.accumulo.core.data.PartialKey;
@@ -130,9 +130,10 @@ private class LockCheckerSession {
     private final HashSet<Pair<String,String>> invalidLocks = new HashSet<>();
 
     private CachedTablet checkLock(CachedTablet tl) {
-      // the goal of this class is to minimize calls out to lockChecker under that assumption that
-      // its a resource synchronized among many threads... want to
-      // avoid fine grained synchronization when binning lots of mutations or ranges... remember
+      // the goal of this class is to minimize calls out to lockChecker under that
+      // assumption that
+      // it is a resource synchronized among many threads... want to
+      // avoid fine-grained synchronization when binning lots of mutations or ranges... remember
       // decisions from the lockChecker in thread local unsynchronized
       // memory
 
@@ -668,17 +669,17 @@ private void requestTabletHosting(ClientContext context,
     List<TKeyExtent> extentsToBringOnline = new ArrayList<>();
     for (var cachedTablet : tabletsWithNoLocation) {
       if (cachedTablet.getAge().compareTo(STALE_DURATION) < 0) {
-        if (cachedTablet.getGoal() == TabletHostingGoal.ONDEMAND) {
+        if (cachedTablet.getAvailability() == TabletAvailability.ONDEMAND) {
           if (!cachedTablet.wasHostingRequested()) {
             extentsToBringOnline.add(cachedTablet.getExtent().toThrift());
             log.trace("requesting ondemand tablet to be hosted {}", cachedTablet.getExtent());
           } else {
             log.trace("ignoring ondemand tablet that already has a hosting request in place {} {}",
                 cachedTablet.getExtent(), cachedTablet.getAge());
           }
-        } else if (cachedTablet.getGoal() == TabletHostingGoal.NEVER) {
+        } else if (cachedTablet.getAvailability() == TabletAvailability.UNHOSTED) {
           throw new InvalidTabletHostingRequestException("Extent " + cachedTablet.getExtent()
-              + " has a tablet hosting goal state " + TabletHostingGoal.NEVER);
+              + " has a tablet availability " + TabletAvailability.UNHOSTED);
         }
       } else {
         // When a tablet does not have a location it is reread from the metadata table before this
@@ -748,7 +749,7 @@ private void lookupTablet(ClientContext context, Text row, boolean retry,
             && ke.prevEndRow().equals(lastEndRow)) {
           locToCache = new CachedTablet(new KeyExtent(ke.tableId(), ke.endRow(), lastEndRow),
               cachedTablet.getTserverLocation(), cachedTablet.getTserverSession(),
-              cachedTablet.getGoal(), cachedTablet.wasHostingRequested());
+              cachedTablet.getAvailability(), cachedTablet.wasHostingRequested());
         } else {
           locToCache = cachedTablet;
         }

core/src/main/java/org/apache/accumulo/core/clientImpl/RootClientTabletCache.java

@@ -31,7 +31,7 @@
 import java.util.function.BiConsumer;
 
 import org.apache.accumulo.core.Constants;
-import org.apache.accumulo.core.client.admin.TabletHostingGoal;
+import org.apache.accumulo.core.client.admin.TabletAvailability;
 import org.apache.accumulo.core.clientImpl.ClientTabletCacheImpl.TabletServerLockChecker;
 import org.apache.accumulo.core.data.Mutation;
 import org.apache.accumulo.core.data.Range;
@@ -124,17 +124,17 @@ protected CachedTablet getRootTabletLocation(ClientContext context) {
 
     if (loc == null || loc.getType() != LocationType.CURRENT) {
       return new CachedTablet(RootTable.EXTENT, Optional.empty(), Optional.empty(),
-          TabletHostingGoal.ALWAYS, false);
+          TabletAvailability.HOSTED, false);
     }
 
     String server = loc.getHostPort();
 
     if (lockChecker.isLockHeld(server, loc.getSession())) {
-      return new CachedTablet(RootTable.EXTENT, server, loc.getSession(), TabletHostingGoal.ALWAYS,
+      return new CachedTablet(RootTable.EXTENT, server, loc.getSession(), TabletAvailability.HOSTED,
           false);
     } else {
       return new CachedTablet(RootTable.EXTENT, Optional.empty(), Optional.empty(),
-          TabletHostingGoal.ALWAYS, false);
+          TabletAvailability.HOSTED, false);
     }
   }