use of org.apache.accumulo.core.manager.thrift.ManagerState in project accumulo by apache.
the class MiniAccumuloClusterImplTest method saneMonitorInfo.
@Test(timeout = 60000)
public void saneMonitorInfo() throws Exception {
ManagerMonitorInfo stats;
while (true) {
stats = accumulo.getManagerMonitorInfo();
if (stats.tableMap.size() <= 2) {
continue;
}
if (null != stats.tServerInfo && stats.tServerInfo.size() == NUM_TSERVERS) {
break;
}
}
List<ManagerState> validStates = Arrays.asList(ManagerState.values());
List<ManagerGoalState> validGoals = Arrays.asList(ManagerGoalState.values());
assertTrue("manager state should be valid.", validStates.contains(stats.state));
assertTrue("manager goal state should be in " + validGoals + ". is " + stats.goalState, validGoals.contains(stats.goalState));
assertNotNull("should have a table map.", stats.tableMap);
assertTrue("root table should exist in " + stats.tableMap.keySet(), stats.tableMap.containsKey(RootTable.ID.canonical()));
assertTrue("meta table should exist in " + stats.tableMap.keySet(), stats.tableMap.containsKey(MetadataTable.ID.canonical()));
assertTrue("our test table should exist in " + stats.tableMap.keySet(), stats.tableMap.containsKey(testTableID));
assertNotNull("there should be tservers.", stats.tServerInfo);
assertEquals(NUM_TSERVERS, stats.tServerInfo.size());
}
use of org.apache.accumulo.core.manager.thrift.ManagerState in project accumulo by apache.
the class Manager method setManagerState.
// @formatter:on
synchronized void setManagerState(ManagerState newState) {
if (state.equals(newState)) {
return;
}
if (!transitionOK[state.ordinal()][newState.ordinal()]) {
log.error("Programmer error: manager should not transition from {} to {}", state, newState);
}
ManagerState oldState = state;
state = newState;
nextEvent.event("State changed from %s to %s", oldState, newState);
if (newState == ManagerState.STOP) {
// Give the server a little time before shutdown so the client
// thread requesting the stop can return
getContext().getScheduledExecutor().scheduleWithFixedDelay(() -> {
// This frees the main thread and will cause the manager to exit
clientService.stop();
Manager.this.nextEvent.event("stopped event loop");
}, 100L, 1000L, TimeUnit.MILLISECONDS);
}
if (oldState != newState && (newState == ManagerState.HAVE_LOCK)) {
upgradeCoordinator.upgradeZookeeper(getContext(), nextEvent);
}
if (oldState != newState && (newState == ManagerState.NORMAL)) {
if (fate != null) {
throw new IllegalStateException("Access to Fate should not have been" + " initialized prior to the Manager finishing upgrades. Please save" + " all logs and file a bug.");
}
upgradeMetadataFuture = upgradeCoordinator.upgradeMetadata(getContext(), nextEvent);
}
}
use of org.apache.accumulo.core.manager.thrift.ManagerState in project accumulo by apache.
the class TabletGroupWatcher method run.
@Override
public void run() {
int[] oldCounts = new int[TabletState.values().length];
EventCoordinator.Listener eventListener = this.manager.nextEvent.getListener();
WalStateManager wals = new WalStateManager(manager.getContext());
while (manager.stillManager()) {
// slow things down a little, otherwise we spam the logs when there are many wake-up events
sleepUninterruptibly(100, TimeUnit.MILLISECONDS);
int totalUnloaded = 0;
int unloaded = 0;
ClosableIterator<TabletLocationState> iter = null;
try {
Map<TableId, MergeStats> mergeStatsCache = new HashMap<>();
Map<TableId, MergeStats> currentMerges = new HashMap<>();
for (MergeInfo merge : manager.merges()) {
if (merge.getExtent() != null) {
currentMerges.put(merge.getExtent().tableId(), new MergeStats(merge));
}
}
// Get the current status for the current list of tservers
SortedMap<TServerInstance, TabletServerStatus> currentTServers = new TreeMap<>();
for (TServerInstance entry : manager.tserverSet.getCurrentServers()) {
currentTServers.put(entry, manager.tserverStatus.get(entry));
}
if (currentTServers.isEmpty()) {
eventListener.waitForEvents(Manager.TIME_TO_WAIT_BETWEEN_SCANS);
synchronized (this) {
lastScanServers = Collections.emptySortedSet();
}
continue;
}
TabletLists tLists = new TabletLists(manager, currentTServers);
ManagerState managerState = manager.getManagerState();
int[] counts = new int[TabletState.values().length];
stats.begin();
// Walk through the tablets in our store, and work tablets
// towards their goal
iter = store.iterator();
while (iter.hasNext()) {
TabletLocationState tls = iter.next();
if (tls == null) {
continue;
}
// ignore entries for tables that do not exist in zookeeper
if (manager.getTableManager().getTableState(tls.extent.tableId()) == null)
continue;
// Don't overwhelm the tablet servers with work
if (tLists.unassigned.size() + unloaded > Manager.MAX_TSERVER_WORK_CHUNK * currentTServers.size()) {
flushChanges(tLists, wals);
tLists.reset();
unloaded = 0;
eventListener.waitForEvents(Manager.TIME_TO_WAIT_BETWEEN_SCANS);
}
TableId tableId = tls.extent.tableId();
TableConfiguration tableConf = manager.getContext().getTableConfiguration(tableId);
MergeStats mergeStats = mergeStatsCache.computeIfAbsent(tableId, k -> {
var mStats = currentMerges.get(k);
return mStats != null ? mStats : new MergeStats(new MergeInfo());
});
TabletGoalState goal = manager.getGoalState(tls, mergeStats.getMergeInfo());
TServerInstance location = tls.getLocation();
TabletState state = tls.getState(currentTServers.keySet());
TabletLogger.missassigned(tls.extent, goal.toString(), state.toString(), tls.future, tls.current, tls.walogs.size());
stats.update(tableId, state);
mergeStats.update(tls.extent, state, tls.chopped, !tls.walogs.isEmpty());
sendChopRequest(mergeStats.getMergeInfo(), state, tls);
sendSplitRequest(mergeStats.getMergeInfo(), state, tls);
// Always follow through with assignments
if (state == TabletState.ASSIGNED) {
goal = TabletGoalState.HOSTED;
}
// if we are shutting down all the tabletservers, we have to do it in order
if ((goal == TabletGoalState.SUSPENDED && state == TabletState.HOSTED) && manager.serversToShutdown.equals(currentTServers.keySet())) {
if (dependentWatcher != null && dependentWatcher.assignedOrHosted() > 0) {
goal = TabletGoalState.HOSTED;
}
}
if (goal == TabletGoalState.HOSTED) {
if ((state != TabletState.HOSTED && !tls.walogs.isEmpty()) && manager.recoveryManager.recoverLogs(tls.extent, tls.walogs))
continue;
switch(state) {
case HOSTED:
if (location.equals(manager.migrations.get(tls.extent)))
manager.migrations.remove(tls.extent);
break;
case ASSIGNED_TO_DEAD_SERVER:
hostDeadTablet(tLists, tls, location, wals);
break;
case SUSPENDED:
hostSuspendedTablet(tLists, tls, location, tableConf);
break;
case UNASSIGNED:
hostUnassignedTablet(tLists, tls.extent, location);
break;
case ASSIGNED:
// Send another reminder
tLists.assigned.add(new Assignment(tls.extent, tls.future));
break;
}
} else {
switch(state) {
case SUSPENDED:
// Request a move to UNASSIGNED, so as to allow balancing to continue.
tLists.suspendedToGoneServers.add(tls);
cancelOfflineTableMigrations(tls.extent);
break;
case UNASSIGNED:
cancelOfflineTableMigrations(tls.extent);
break;
case ASSIGNED_TO_DEAD_SERVER:
unassignDeadTablet(tLists, tls, wals);
break;
case HOSTED:
TServerConnection client = manager.tserverSet.getConnection(location);
if (client != null) {
client.unloadTablet(manager.managerLock, tls.extent, goal.howUnload(), manager.getSteadyTime());
unloaded++;
totalUnloaded++;
} else {
Manager.log.warn("Could not connect to server {}", location);
}
break;
case ASSIGNED:
break;
}
}
counts[state.ordinal()]++;
}
flushChanges(tLists, wals);
// provide stats after flushing changes to avoid race conditions w/ delete table
stats.end(managerState);
// Report changes
for (TabletState state : TabletState.values()) {
int i = state.ordinal();
if (counts[i] > 0 && counts[i] != oldCounts[i]) {
manager.nextEvent.event("[%s]: %d tablets are %s", store.name(), counts[i], state.name());
}
}
Manager.log.debug(String.format("[%s]: scan time %.2f seconds", store.name(), stats.getScanTime() / 1000.));
oldCounts = counts;
if (totalUnloaded > 0) {
manager.nextEvent.event("[%s]: %d tablets unloaded", store.name(), totalUnloaded);
}
updateMergeState(mergeStatsCache);
synchronized (this) {
lastScanServers = ImmutableSortedSet.copyOf(currentTServers.keySet());
}
if (manager.tserverSet.getCurrentServers().equals(currentTServers.keySet())) {
Manager.log.debug(String.format("[%s] sleeping for %.2f seconds", store.name(), Manager.TIME_TO_WAIT_BETWEEN_SCANS / 1000.));
eventListener.waitForEvents(Manager.TIME_TO_WAIT_BETWEEN_SCANS);
} else {
Manager.log.info("Detected change in current tserver set, re-running state machine.");
}
} catch (Exception ex) {
Manager.log.error("Error processing table state for store " + store.name(), ex);
if (ex.getCause() != null && ex.getCause() instanceof BadLocationStateException) {
repairMetadata(((BadLocationStateException) ex.getCause()).getEncodedEndRow());
} else {
sleepUninterruptibly(Manager.WAIT_BETWEEN_ERRORS, TimeUnit.MILLISECONDS);
}
} finally {
if (iter != null) {
try {
iter.close();
} catch (IOException ex) {
Manager.log.warn("Error closing TabletLocationState iterator: " + ex, ex);
}
}
}
}
}
Aggregations