Rename hosting goal to availability

Author: DomGarguilo

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

@@ -45,11 +45,11 @@ public interface ImportConfiguration {
   boolean isKeepMappings();
 
   /**
-   * @return the initial hosting goal for the table
+   * @return the initial tablet availability for the table
    *
    * @since 4.0.0
    */
-  TabletHostingGoal getInitialHostingGoal();
+  TabletAvailability getInitialAvailability();
 
   /**
    * A ImportConfiguration builder
@@ -81,12 +81,12 @@ interface Builder {
     Builder setKeepMappings(boolean keepMappings);
 
     /**
-     * set the initial hosting goal for the table
+     * set the initial tablet availability for the table
      *
-     * @param initialTabletGoal the initial hosting goal for the table
+     * @param initialAvailability the initial tablet availability for the table
      * @since 4.0.0
      */
-    Builder setInitialHostingGoal(TabletHostingGoal initialTabletGoal);
+    Builder setInitialAvailability(TabletAvailability initialAvailability);
 
     /**
      * Build the import table configuration

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

@@ -19,15 +19,15 @@
 package org.apache.accumulo.core.clientImpl;
 
 import org.apache.accumulo.core.client.admin.ImportConfiguration;
-import org.apache.accumulo.core.client.admin.TabletHostingGoal;
+import org.apache.accumulo.core.client.admin.TabletAvailability;
 
 import com.google.common.base.Preconditions;
 
 public class ImportConfigurationImpl implements ImportConfiguration, ImportConfiguration.Builder {
   private boolean built = false;
   private boolean keepOffline = false;
   private boolean keepMappingsFile = false;
-  private TabletHostingGoal initialHostingGoal = TabletHostingGoal.ONDEMAND;
+  private TabletAvailability initialAvailability = TabletAvailability.ONDEMAND;
 
   private final static String BUILT_ERROR_MSG = "ImportConfiguration was already built";
   private final static String NOT_BUILT_ERROR_MSG = "ImportConfiguration was not built yet";
@@ -47,10 +47,10 @@ public Builder setKeepMappings(boolean keepMappings) {
   }
 
   @Override
-  public Builder setInitialHostingGoal(TabletHostingGoal initialTabletHostingGoal) {
+  public Builder setInitialAvailability(TabletAvailability initialAvailability) {
     Preconditions.checkState(!built, BUILT_ERROR_MSG);
-    Preconditions.checkState(initialTabletHostingGoal != null, "initialTabletHostingGoal is null");
-    this.initialHostingGoal = initialTabletHostingGoal;
+    Preconditions.checkState(initialAvailability != null, "initialAvailability is null");
+    this.initialAvailability = initialAvailability;
     return this;
   }
 
@@ -73,8 +73,8 @@ public boolean isKeepMappings() {
   }
 
   @Override
-  public TabletHostingGoal getInitialHostingGoal() {
+  public TabletAvailability getInitialAvailability() {
     Preconditions.checkState(built, NOT_BUILT_ERROR_MSG);
-    return initialHostingGoal;
+    return initialAvailability;
   }
 }

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

@@ -1637,7 +1637,7 @@ public void importTable(String tableName, Set<String> importDirs, ImportConfigur
     args.add(0, ByteBuffer.wrap(tableName.getBytes(UTF_8)));
     args.add(1, ByteBuffer.wrap(Boolean.toString(keepOffline).getBytes(UTF_8)));
     args.add(2, ByteBuffer.wrap(Boolean.toString(keepMapping).getBytes(UTF_8)));
-    args.add(3, ByteBuffer.wrap(ic.getInitialHostingGoal().name().getBytes(UTF_8)));
+    args.add(3, ByteBuffer.wrap(ic.getInitialAvailability().name().getBytes(UTF_8)));
     checkedImportDirs.stream().map(s -> s.getBytes(UTF_8)).map(ByteBuffer::wrap).forEach(args::add);
 
     try {

server/manager/src/main/java/org/apache/accumulo/manager/FateServiceHandler.java

@@ -575,8 +575,8 @@ public void executeFateOperation(TInfo tinfo, TCredentials c, TFateId opid, Fate
             validateName(arguments.get(0), tableOp, NEW_TABLE_NAME.and(NOT_BUILTIN_TABLE));
         boolean keepOffline = Boolean.parseBoolean(ByteBufferUtil.toString(arguments.get(1)));
         boolean keepMappings = Boolean.parseBoolean(ByteBufferUtil.toString(arguments.get(2)));
-          TabletAvailability initialAvailability =
-                  TabletAvailability.valueOf(ByteBufferUtil.toString(arguments.get(3)));
+        TabletAvailability initialAvailability =
+            TabletAvailability.valueOf(ByteBufferUtil.toString(arguments.get(3)));
 
         List<ByteBuffer> exportDirArgs =
             arguments.stream().skip(IMPORT_DIR_OFFSET + 1).collect(Collectors.toList());

server/manager/src/main/java/org/apache/accumulo/manager/tableOps/tableImport/ImportTable.java

@@ -33,7 +33,7 @@
 
 import org.apache.accumulo.core.Constants;
 import org.apache.accumulo.core.client.AccumuloException;
-import org.apache.accumulo.core.client.admin.TabletHostingGoal;
+import org.apache.accumulo.core.client.admin.TabletAvailability;
 import org.apache.accumulo.core.clientImpl.AcceptableThriftTableOperationException;
 import org.apache.accumulo.core.clientImpl.TableOperationsImpl;
 import org.apache.accumulo.core.clientImpl.thrift.TableOperation;
@@ -65,16 +65,16 @@ public class ImportTable extends ManagerRepo {
   private final ImportedTableInfo tableInfo;
 
   public ImportTable(String user, String tableName, Set<String> exportDirs, NamespaceId namespaceId,
-      boolean keepMappings, boolean keepOffline, TabletHostingGoal initialHostingGoal) {
+      boolean keepMappings, boolean keepOffline, TabletAvailability initialAvailability) {
     tableInfo = new ImportedTableInfo();
     tableInfo.tableName = tableName;
     tableInfo.user = user;
     tableInfo.namespaceId = namespaceId;
     tableInfo.directories = parseExportDir(exportDirs);
     tableInfo.keepMappings = keepMappings;
     tableInfo.keepOffline = keepOffline;
-    Preconditions.checkState(initialHostingGoal != null, "initialHostingGoal is null");
-    tableInfo.initialHostingGoal = initialHostingGoal;
+    Preconditions.checkState(initialAvailability != null, "initialAvailability is null");
+    tableInfo.initialAvailability = initialAvailability;
   }
 
   @Override

server/manager/src/main/java/org/apache/accumulo/manager/tableOps/tableImport/ImportedTableInfo.java

@@ -21,7 +21,7 @@
 import java.io.Serializable;
 import java.util.List;
 
-import org.apache.accumulo.core.client.admin.TabletHostingGoal;
+import org.apache.accumulo.core.client.admin.TabletAvailability;
 import org.apache.accumulo.core.data.NamespaceId;
 import org.apache.accumulo.core.data.TableId;
 
@@ -37,7 +37,7 @@ class ImportedTableInfo implements Serializable {
   public String exportFile;
   public boolean keepMappings;
   public boolean keepOffline;
-  public TabletHostingGoal initialHostingGoal = TabletHostingGoal.ONDEMAND;
+  public TabletAvailability initialAvailability = TabletAvailability.ONDEMAND;
 
   static class DirectoryMapping implements Serializable {
     private static final long serialVersionUID = 1L;

server/manager/src/main/java/org/apache/accumulo/manager/tableOps/tableImport/PopulateMetadataTable.java

@@ -20,6 +20,7 @@
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.apache.accumulo.core.Constants.IMPORT_MAPPINGS_FILE;
+import static org.apache.accumulo.core.metadata.schema.MetadataSchema.TabletsSection.TabletColumnFamily.AVAILABILITY_COLUMN;
 
 import java.io.BufferedInputStream;
 import java.io.BufferedReader;
@@ -128,11 +129,11 @@ public Repo<Manager> call(long tid, Manager manager) throws Exception {
           Text currentRow = null;
           int dirCount = 0;
 
-            TabletAvailability initialHostingGoal = tableInfo.initialHostingGoal;
-          if (initialHostingGoal == null) {
-            log.error("Initial hosting goal is null and shouldn't be, defaulting to "
+          TabletAvailability initialAvailability = tableInfo.initialAvailability;
+          if (initialAvailability == null) {
+            log.error("Initial tablet availability is null and shouldn't be, defaulting to "
                 + TabletAvailability.ONDEMAND);
-            initialHostingGoal = TabletAvailability.ONDEMAND;
+            initialAvailability = TabletAvailability.ONDEMAND;
           }
 
           while (true) {
@@ -165,8 +166,7 @@ public Repo<Manager> call(long tid, Manager manager) throws Exception {
             if (m == null || !currentRow.equals(metadataRow)) {
 
               if (m != null) {
-                  TabletAvailability.GOAL_COLUMN.put(m,
-                          TabletAvailabilityUtil.toValue(initialHostingGoal));
+                AVAILABILITY_COLUMN.put(m, TabletAvailabilityUtil.toValue(initialAvailability));
                 mbw.addMutation(m);
               }
 
@@ -181,9 +181,8 @@ public Repo<Manager> call(long tid, Manager manager) throws Exception {
               currentRow = metadataRow;
             }
 
-            // add the initial hosting goal
-              TabletAvailability.GOAL_COLUMN.put(m,
-                      TabletAvailabilityUtil.toValue(initialHostingGoal));
+            // add the initial tablet availability
+            AVAILABILITY_COLUMN.put(m, TabletAvailabilityUtil.toValue(initialAvailability));
 
             m.put(key.getColumnFamily(), cq, val);
 

test/src/main/java/org/apache/accumulo/test/ImportExportIT.java

@@ -49,7 +49,7 @@
 import org.apache.accumulo.core.client.TableNotFoundException;
 import org.apache.accumulo.core.client.admin.ImportConfiguration;
 import org.apache.accumulo.core.client.admin.NewTableConfiguration;
-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.Range;
@@ -96,18 +96,19 @@ protected Duration defaultTimeout() {
   }
 
   /**
-   * Test that we can override a hosting goal when importing a table.
+   * Test that we can override a tablet availability when importing a table.
    */
   @Test
-  public void importChangeHostingGoal() throws Exception {
+  public void overrideAvailabilityOnImport() throws Exception {
     try (AccumuloClient client = Accumulo.newClient().from(getClientProps()).build()) {
 
       String[] tableNames = getUniqueNames(2);
       String srcTable = tableNames[0], destTable = tableNames[1];
 
-      // create the source table with the initial hosting goal
-      TabletHostingGoal srcGoal = TabletHostingGoal.ALWAYS;
-      NewTableConfiguration ntc = new NewTableConfiguration().withInitialHostingGoal(srcGoal);
+      // create the source table with the initial tablet availability
+      TabletAvailability srcAvailability = TabletAvailability.HOSTED;
+      NewTableConfiguration ntc =
+          new NewTableConfiguration().withInitialTabletAvailability(srcAvailability);
       client.tableOperations().create(srcTable, ntc);
 
       populateTable(client, srcTable);
@@ -121,8 +122,8 @@ public void importChangeHostingGoal() throws Exception {
       log.info("Exporting table to {}", exportDir);
       log.info("Importing table from {}", Arrays.toString(importDirs));
 
-      // ensure the table is the hosting goal we expect
-      waitForHostingGoal(client, srcTable, srcGoal);
+      // ensure the table has the tablet availability we expect
+      waitForAvailability(client, srcTable, srcAvailability);
 
       // Offline the table
       client.tableOperations().offline(srcTable, true);
@@ -132,16 +133,16 @@ public void importChangeHostingGoal() throws Exception {
       copyExportedFilesToImportDirs(fs, exportDir, importDirs);
 
       // Import the exported data into a new table
-      final TabletHostingGoal newHostingGoal = TabletHostingGoal.NEVER;
-      assertNotEquals(srcGoal, newHostingGoal,
-          "New hosting goal should be different from the old one in order to test override.");
+      final TabletAvailability newAvailability = TabletAvailability.UNHOSTED;
+      assertNotEquals(srcAvailability, newAvailability,
+          "New tablet availability should be different from the old one in order to test we can override.");
 
       ImportConfiguration importConfig =
-          ImportConfiguration.builder().setInitialHostingGoal(newHostingGoal).build();
+          ImportConfiguration.builder().setInitialAvailability(newAvailability).build();
       client.tableOperations().importTable(destTable,
           Arrays.stream(importDirs).map(Path::toString).collect(Collectors.toSet()), importConfig);
 
-      waitForHostingGoal(client, destTable, newHostingGoal);
+      waitForAvailability(client, destTable, newAvailability);
     }
   }
 
@@ -451,17 +452,19 @@ private void copyExportedFilesToImportDirs(FileSystem fs, Path exportDir, Path[]
     }
   }
 
-  private static void waitForHostingGoal(AccumuloClient client, String tableName,
-      TabletHostingGoal goal) {
+  private static void waitForAvailability(AccumuloClient client, String tableName,
+      TabletAvailability expectedAvailability) {
     Wait.waitFor(() -> client.tableOperations().getTabletInformation(tableName, new Range())
         .allMatch(tabletInformation -> {
-          TabletHostingGoal currentGoal = tabletInformation.getHostingGoal();
-          boolean goalReached = currentGoal == goal;
+          TabletAvailability currentAvailability = tabletInformation.getTabletAvailability();
+          boolean goalReached = currentAvailability == expectedAvailability;
           if (!goalReached) {
-            log.info("Current hosting goal: " + currentGoal + ". Waiting for " + goal);
+            log.info("Current tablet availability: " + currentAvailability + ". Waiting for "
+                + expectedAvailability);
           }
           return goalReached;
-        }), 30_000L, 1_000L, "Timed out waiting for hosting goal " + goal + " on " + tableName);
+        }), 30_000L, 1_000L,
+        "Timed out waiting for tablet availability " + expectedAvailability + " on " + tableName);
   }
 
 }