public void run()

in server/tserver/src/main/java/org/apache/accumulo/tserver/AssignmentHandler.java [63:207]
113 lines of code
15 McCabe index (conditional complexity)

  public void run() {
    synchronized (server.unopenedTablets) {
      synchronized (server.openingTablets) {
        synchronized (server.onlineTablets) {
          // nothing should be moving between sets, do a sanity
          // check
          Set<KeyExtent> unopenedOverlapping =
              KeyExtent.findOverlapping(extent, server.unopenedTablets);
          Set<KeyExtent> openingOverlapping =
              KeyExtent.findOverlapping(extent, server.openingTablets);
          Set<KeyExtent> onlineOverlapping =
              KeyExtent.findOverlapping(extent, server.onlineTablets.snapshot());

          if (openingOverlapping.contains(extent) || onlineOverlapping.contains(extent)) {
            return;
          }

          if (!unopenedOverlapping.contains(extent)) {
            log.info("assignment {} no longer in the unopened set", extent);
            return;
          }

          if (unopenedOverlapping.size() != 1 || !openingOverlapping.isEmpty()
              || !onlineOverlapping.isEmpty()) {
            throw new IllegalStateException(
                "overlaps assigned " + extent + " " + !server.unopenedTablets.contains(extent) + " "
                    + unopenedOverlapping + " " + openingOverlapping + " " + onlineOverlapping);
          }
        }

        server.unopenedTablets.remove(extent);
        server.openingTablets.add(extent);
      }
    }

    // check Metadata table before accepting assignment
    TabletMetadata tabletMetadata = null;
    boolean canLoad = false;
    try {
      tabletMetadata = server.getContext().getAmple().readTablet(extent);

      canLoad = checkTabletMetadata(extent, server.getTabletSession(), tabletMetadata);
    } catch (Exception e) {
      synchronized (server.openingTablets) {
        server.openingTablets.remove(extent);
        server.openingTablets.notifyAll();
      }
      TabletLogger.tabletLoadFailed(extent, e);
      server.enqueueManagerMessage(new TabletStatusMessage(TabletLoadState.LOAD_FAILURE, extent));
      throw new RuntimeException(e);
    }

    if (!canLoad) {
      log.debug("Reporting tablet {} assignment failure: unable to verify Tablet Information",
          extent);
      synchronized (server.openingTablets) {
        server.openingTablets.remove(extent);
        server.openingTablets.notifyAll();
      }
      server.enqueueManagerMessage(new TabletStatusMessage(TabletLoadState.LOAD_FAILURE, extent));
      return;
    }

    Tablet tablet = null;
    boolean successful = false;

    try (var recoveryMemory = server.acquireRecoveryMemory(tabletMetadata)) {
      TabletResourceManager trm = server.resourceManager.createTabletResourceManager(extent,
          server.getTableConfiguration(extent));

      tablet = new Tablet(server, extent, trm, tabletMetadata);
      // If a minor compaction starts after a tablet opens, this indicates a log recovery
      // occurred. This recovered data must be minor compacted.
      // There are three reasons to wait for this minor compaction to finish before placing the
      // tablet in online tablets.
      //
      // 1) The log recovery code does not handle data written to the tablet on multiple tablet
      // servers.
      // 2) The log recovery code does not block if memory is full. Therefore recovering lots of
      // tablets that use a lot of memory could run out of memory.
      // 3) The minor compaction finish event did not make it to the logs (the file will be in
      // metadata, preventing replay of compacted data)... but do not
      // want a majc to wipe the file out from metadata and then have another process failure...
      // this could cause duplicate data to replay.
      if (tablet.getNumEntriesInMemory() > 0
          && !tablet.minorCompactNow(MinorCompactionReason.RECOVERY)) {
        throw new RuntimeException("Minor compaction after recovery fails for " + extent);
      }

      Assignment assignment =
          new Assignment(extent, server.getTabletSession(), tabletMetadata.getLast());
      TabletStateStore.setLocation(server.getContext(), assignment);

      // refresh the tablet metadata after setting the location (See #3358)
      tablet.refreshMetadata(RefreshPurpose.LOAD);

      synchronized (server.openingTablets) {
        synchronized (server.onlineTablets) {
          server.openingTablets.remove(extent);
          server.onlineTablets.put(extent, tablet);
          server.openingTablets.notifyAll();
          server.recentlyUnloadedCache.remove(tablet.getExtent());
        }
      }

      tablet = null; // release this reference
      successful = true;
    } catch (Exception e) {
      TabletLogger.tabletLoadFailed(extent, e);
    }

    if (successful) {
      server.enqueueManagerMessage(new TabletStatusMessage(TabletLoadState.LOADED, extent));
    } else {
      synchronized (server.unopenedTablets) {
        synchronized (server.openingTablets) {
          server.openingTablets.remove(extent);
          server.unopenedTablets.add(extent);
          server.openingTablets.notifyAll();
        }
      }
      log.warn("failed to open tablet {} reporting failure to manager", extent);
      server.enqueueManagerMessage(new TabletStatusMessage(TabletLoadState.LOAD_FAILURE, extent));
      long reschedule = Math.min((1L << Math.min(32, retryAttempt)) * 1000, MINUTES.toMillis(10));
      log.warn(String.format("rescheduling tablet load in %.2f seconds", reschedule / 1000.));
      ThreadPools.watchCriticalScheduledTask(
          this.server.getContext().getScheduledExecutor().schedule(new Runnable() {
            @Override
            public void run() {
              log.info("adding tablet {} back to the assignment pool (retry {})", extent,
                  retryAttempt);
              AssignmentHandler handler = new AssignmentHandler(server, extent, retryAttempt + 1);
              if (extent.isMeta()) {
                if (extent.isRootTablet()) {
                  Threads.createThread("Root tablet assignment retry", handler).start();
                } else {
                  server.resourceManager.addMetaDataAssignment(extent, log, handler);
                }
              } else {
                server.resourceManager.addAssignment(extent, log, handler);
              }
            }
          }, reschedule, TimeUnit.MILLISECONDS));
    }
  }