Use "Tablet Availability" rather than "Hosting Goal" (apache#3969)

This update replaces uses of hosting goal related nomenclature with tablet availability related nomenclature instead.

The hosting values ALWAYS, ONDEMAND, and NEVER have been updated to HOSTED, ONDEMAND, and UNHOSTED. References to hosting goal and other goal related uses have been replaced with tablet availability and/or availability equivalents. Attempts have been made to update the corresponding JavaDocs along the way.

Hopefully after a couple of reviews all of the relevant references that need to be changed have been found. Any additional ones missed can be updated as needed. 

Several classes have been renamed in the process. These include:

- `HostingGoalForTablet` -> `AvailabilityForTablet`
- `TabletHostingGoal` -> `TabletAvailability`
- `THostingGoal` -> `TTabletAvailability`
- `SetHostingGoal` -> `SetTabletAvailability`
  -  the containing package was updated from `.../tableOps/goal` to
     `.../tableOps/availability`
- `GetTabletHostingGoalCommand` -> `GetAvailabilityCommand`
- `SetTabletHostingGoalCommand` -> `SetAvailabilityCommand`

The metadata schema was modified.
Moved `hosting:availability` and `hosting:requested` from the `HostingColumnFamily` class to the `TabletColumnFamily` class. They are now represented as `~tab:availability` and `~tab:requestToHost`.

Corrected two IT tests that were failing when performing a full IT build.
	`ShellServerIT.testGetAvailabilityCommand_DelayedSplits`
	`ShellCreateTableIT.testCreateTableWithInitialTabletAvailability`

Will close apache#3859

-----

Co-authored-by: Christopher Tubbs <ctubbsii@apache.org>
Co-authored-by: EdColeman <dev1@etcoleman.com>
Co-authored-by: Dave Marion <dlmarion@apache.org>
Co-authored-by: Keith Turner <kturner@apache.org>

Author: 5 people

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);
     }
   }