Replace ClientContext/TabletLocator/MetadataServicer with AccumuloTableInfoFetcher facade

core/connection-pool/src/main/java/datawave/core/common/connection/AccumuloConnectionFactory.java

@@ -5,10 +5,8 @@
 import java.util.Map;
 
 import org.apache.accumulo.core.client.AccumuloClient;
-import org.apache.accumulo.core.clientImpl.ClientContext;
 
 import datawave.core.common.result.ConnectionPool;
-import datawave.webservice.common.connection.WrappedAccumuloClient;
 
 public interface AccumuloConnectionFactory extends AutoCloseable {
 
@@ -110,21 +108,4 @@ AccumuloClient getClient(String userDN, Collection<String> proxyServers, String
      * @return A map representation
      */
     Map<String,String> getTrackingMap(StackTraceElement[] stackTrace);
-
-    /**
-     * Utility method to unwrap the ClientContext instance within {@link WrappedAccumuloClient} as needed
-     *
-     * @param accumuloClient
-     *            {@link AccumuloClient} instance
-     * @return {@link WrappedAccumuloClient#getReal()}, if applicable; accumuloClient itself, if it implements {@link ClientContext}; otherwise returns null
-     */
-    static ClientContext getClientContext(AccumuloClient accumuloClient) {
-        ClientContext cc = null;
-        if (accumuloClient instanceof WrappedAccumuloClient) {
-            cc = (ClientContext) ((WrappedAccumuloClient) accumuloClient).getReal();
-        } else if (accumuloClient instanceof ClientContext) {
-            cc = (ClientContext) accumuloClient;
-        }
-        return cc;
-    }
 }

core/connection-pool/src/main/java/datawave/core/common/connection/AccumuloTableInfoFetcher.java

@@ -0,0 +1,117 @@
+package datawave.core.common.connection;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.apache.accumulo.core.client.AccumuloClient;
+import org.apache.accumulo.core.client.AccumuloException;
+import org.apache.accumulo.core.client.AccumuloSecurityException;
+import org.apache.accumulo.core.client.TableNotFoundException;
+import org.apache.accumulo.core.client.admin.ActiveCompaction;
+import org.apache.accumulo.core.client.admin.Locations;
+import org.apache.accumulo.core.data.Range;
+import org.apache.accumulo.core.data.TableId;
+
+/**
+ * Facade that centralizes Accumulo table metadata operations behind public APIs.
+ * <p>
+ * This class replaces direct usage of non-public Accumulo internals ({@code ClientContext}, {@code ThriftClientTypes}, {@code TabletLocator},
+ * {@code MetadataServicer}, etc.) with their public API equivalents. All methods delegate to {@link org.apache.accumulo.core.client.admin.TableOperations} or
+ * {@link org.apache.accumulo.core.client.admin.InstanceOperations}.
+ *
+ * @see <a href="https://github.com/NationalSecurityAgency/datawave/issues/2443">Issue #2443</a>
+ */
+public class AccumuloTableInfoFetcher {
+
+    private final AccumuloClient client;
+
+    public AccumuloTableInfoFetcher(AccumuloClient client) {
+        this.client = client;
+    }
+
+    /**
+     * Get the TableId for a table name using the public {@code tableIdMap()} API.
+     *
+     * @param tableName
+     *            the table name
+     * @return the TableId
+     * @throws TableNotFoundException
+     *             if the table does not exist
+     */
+    public TableId getTableId(String tableName) throws TableNotFoundException {
+        String id = client.tableOperations().tableIdMap().get(tableName);
+        if (id == null) {
+            throw new TableNotFoundException(null, tableName, "Table not found in tableIdMap");
+        }
+        return TableId.of(id);
+    }
+
+    /**
+     * Check if a table exists using the public {@code exists()} API.
+     *
+     * @param tableName
+     *            the table name
+     * @return true if the table exists
+     */
+    public boolean tableExists(String tableName) {
+        return client.tableOperations().exists(tableName);
+    }
+
+    /**
+     * Check if a table is online using the public {@code isOnline()} API.
+     *
+     * @param tableName
+     *            the table name
+     * @return true if the table is online
+     * @throws TableNotFoundException
+     *             if the table does not exist
+     * @throws AccumuloException
+     *             if a general Accumulo error occurs
+     */
+    public boolean isTableOnline(String tableName) throws TableNotFoundException, AccumuloException {
+        return client.tableOperations().isOnline(tableName);
+    }
+
+    /**
+     * Get tablet locations for the given ranges using the public {@code locate()} API.
+     *
+     * @param tableName
+     *            the table name
+     * @param ranges
+     *            the ranges to locate
+     * @return the Locations result
+     * @throws TableNotFoundException
+     *             if the table does not exist
+     * @throws AccumuloException
+     *             if a general Accumulo error occurs
+     * @throws AccumuloSecurityException
+     *             if a security error occurs
+     */
+    public Locations getTabletLocations(String tableName, Collection<Range> ranges)
+                    throws TableNotFoundException, AccumuloException, AccumuloSecurityException {
+        return client.tableOperations().locate(tableName, ranges);
+    }
+
+    /**
+     * Get the count of running major compactions across all tablet servers using the public {@code getActiveCompactions()} API.
+     * <p>
+     * Note: This counts only running compactions (not queued), which differs slightly from the original Thrift-based implementation that also counted queued
+     * compactions. This is acceptable because the MAJC_THRESHOLD default is 3000 (a high safety margin) and this is polled on each bulk load cycle.
+     *
+     * @return the number of active major compactions
+     * @throws AccumuloException
+     *             if a general Accumulo error occurs
+     * @throws AccumuloSecurityException
+     *             if a security error occurs
+     */
+    public int getMajorCompactionCount() throws AccumuloException, AccumuloSecurityException {
+        int count = 0;
+        List<ActiveCompaction> compactions = client.instanceOperations().getActiveCompactions();
+        for (ActiveCompaction compaction : compactions) {
+            if (compaction.getType() == ActiveCompaction.CompactionType.MAJOR || compaction.getType() == ActiveCompaction.CompactionType.FULL) {
+                count++;
+            }
+        }
+        return count;
+    }
+}

core/connection-pool/src/test/java/datawave/core/common/connection/AccumuloTableInfoFetcherTest.java

@@ -0,0 +1,81 @@
+package datawave.core.common.connection;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.accumulo.core.client.AccumuloClient;
+import org.apache.accumulo.core.client.TableNotFoundException;
+import org.apache.accumulo.core.client.admin.Locations;
+import org.apache.accumulo.core.data.Range;
+import org.apache.accumulo.core.data.TableId;
+import org.apache.accumulo.core.data.TabletId;
+import org.junit.Before;
+import org.junit.Test;
+
+import datawave.accumulo.inmemory.InMemoryAccumuloClient;
+import datawave.accumulo.inmemory.InMemoryInstance;
+
+public class AccumuloTableInfoFetcherTest {
+
+    private static final String TEST_TABLE = "testTable";
+    private AccumuloClient client;
+    private AccumuloTableInfoFetcher fetcher;
+
+    @Before
+    public void setup() throws Exception {
+        InMemoryInstance instance = new InMemoryInstance();
+        client = new InMemoryAccumuloClient("root", instance);
+        client.tableOperations().create(TEST_TABLE);
+        fetcher = new AccumuloTableInfoFetcher(client);
+    }
+
+    @Test
+    public void testGetTableId() throws Exception {
+        TableId tableId = fetcher.getTableId(TEST_TABLE);
+        assertNotNull(tableId);
+        // Verify it matches the tableIdMap entry
+        String expectedId = client.tableOperations().tableIdMap().get(TEST_TABLE);
+        assertEquals(expectedId, tableId.canonical());
+    }
+
+    @Test(expected = TableNotFoundException.class)
+    public void testGetTableIdNonExistent() throws Exception {
+        fetcher.getTableId("nonExistentTable");
+    }
+
+    @Test
+    public void testTableExists() {
+        assertTrue(fetcher.tableExists(TEST_TABLE));
+        assertFalse(fetcher.tableExists("nonExistentTable"));
+    }
+
+    @Test
+    public void testIsTableOnline() throws Exception {
+        // InMemoryAccumuloClient.isOnline() returns false, but the API call should succeed
+        boolean online = fetcher.isTableOnline(TEST_TABLE);
+        // InMemory always returns false; just verify no exception is thrown
+        assertFalse(online);
+    }
+
+    @Test
+    public void testGetTabletLocations() throws Exception {
+        Locations locations = fetcher.getTabletLocations(TEST_TABLE, Collections.singletonList(new Range()));
+        assertNotNull(locations);
+        Map<TabletId,List<Range>> byTablet = locations.groupByTablet();
+        assertNotNull(byTablet);
+        assertFalse(byTablet.isEmpty());
+    }
+
+    @Test
+    public void testGetMajorCompactionCount() throws Exception {
+        // InMemoryAccumuloClient returns empty list for getActiveCompactions
+        int count = fetcher.getMajorCompactionCount();
+        assertEquals(0, count);
+    }
+}

import-control-accumulo.xml

@@ -19,9 +19,8 @@
     <allow pkg="org.apache.accumulo.core.spi"/>
 
     <!-- Temporarily allow some specific classes until accumulo
-    team seperates parts of that into public api -->
+    team separates parts of that into public api -->
     <allow class="org.apache.accumulo.core.conf.Property"/>
-    <allow class="org.apache.accumulo.core.clientImpl.TabletLocator"/>
     <allow class="org.apache.accumulo.core.file.keyfunctor.KeyFunctor" />
     <!-- disallow everything else coming from accumulo -->
     <disallow pkg="org.apache.accumulo"/>

warehouse/core/pom.xml

@@ -60,6 +60,11 @@
             <groupId>gov.nsa.datawave.core</groupId>
             <artifactId>common-utils</artifactId>
         </dependency>
+        <dependency>
+            <groupId>gov.nsa.datawave.core</groupId>
+            <artifactId>datawave-core-connection-pool</artifactId>
+            <version>${project.version}</version>
+        </dependency>
         <dependency>
             <groupId>gov.nsa.datawave.core</groupId>
             <artifactId>metadata-utils</artifactId>