public void inform()

in solr/core/src/java/org/apache/solr/handler/ReplicationHandler.java [1227:1362]
116 lines of code
41 McCabe index (conditional complexity)

  public void inform(SolrCore core) {
    this.core = core;
    registerCloseHook();
    Object nbtk = initArgs.get(NUMBER_BACKUPS_TO_KEEP_INIT_PARAM);
    if (nbtk != null) {
      replicationHandlerConfig.numberBackupsToKeep = Integer.parseInt(nbtk.toString());
    } else {
      replicationHandlerConfig.numberBackupsToKeep = 0;
    }
    NamedList<?> follower = (NamedList<?>) initArgs.get("follower");
    boolean enableFollower = isEnabled(follower);
    if (enableFollower) {
      currentIndexFetcher = pollingIndexFetcher = new IndexFetcher(follower, this, core);
      setupPolling((String) follower.get(ReplicationAPIBase.POLL_INTERVAL));
      isFollower = true;
    }
    NamedList<?> leader = (NamedList<?>) initArgs.get("leader");
    boolean enableLeader = isEnabled(leader);

    if (enableLeader || (enableFollower && !currentIndexFetcher.fetchFromLeader)) {
      if (core.getCoreContainer().getZkController() != null) {
        log.warn(
            "SolrCloud is enabled for core {} but so is old-style replication. "
                + "Make sure you intend this behavior, it usually indicates a mis-configuration. "
                + "Leader setting is {} and follower setting is {}",
            core.getName(),
            enableLeader,
            enableFollower);
      }
    }

    if (!enableFollower && !enableLeader) {
      enableLeader = true;
      leader = new NamedList<>();
    }

    if (enableLeader) {
      includeConfFiles = (String) leader.get(CONF_FILES);
      if (includeConfFiles != null && includeConfFiles.trim().length() > 0) {
        String[] files = includeConfFiles.split(",");
        for (String file : files) {
          if (file.trim().length() == 0) continue;
          String[] strs = file.trim().split(":");
          // if there is an alias add it, or it is null
          confFileNameAlias.add(strs[0], strs.length > 1 ? strs[1] : null);
        }
        log.info("Replication enabled for following config files: {}", includeConfFiles);
      }
      List<?> backup = leader.getAll("backupAfter");
      boolean backupOnCommit = backup.contains("commit");
      boolean backupOnOptimize = !backupOnCommit && backup.contains("optimize");
      List<?> replicateAfter = leader.getAll(REPLICATE_AFTER);
      replicateOnCommit = replicateAfter.contains("commit");
      replicateOnOptimize = !replicateOnCommit && replicateAfter.contains("optimize");

      if (!replicateOnCommit && !replicateOnOptimize) {
        replicateOnCommit = true;
      }

      // if we only want to replicate on optimize, we need the deletion policy to
      // save the last optimized commit point.
      if (replicateOnOptimize) {
        IndexDeletionPolicyWrapper wrapper = core.getDeletionPolicy();
        IndexDeletionPolicy policy = wrapper == null ? null : wrapper.getWrappedDeletionPolicy();
        if (policy instanceof SolrDeletionPolicy solrPolicy) {
          if (solrPolicy.getMaxOptimizedCommitsToKeep() < 1) {
            solrPolicy.setMaxOptimizedCommitsToKeep(1);
          }
        } else {
          log.warn("Replication can't call setMaxOptimizedCommitsToKeep on {}", policy);
        }
      }

      if (replicateOnOptimize || backupOnOptimize) {
        core.getUpdateHandler()
            .registerOptimizeCallback(getEventListener(backupOnOptimize, replicateOnOptimize));
      }
      if (replicateOnCommit || backupOnCommit) {
        replicateOnCommit = true;
        core.getUpdateHandler()
            .registerCommitCallback(getEventListener(backupOnCommit, replicateOnCommit));
      }
      if (replicateAfter.contains("startup")) {
        replicateOnStart = true;
        RefCounted<SolrIndexSearcher> s = core.getNewestSearcher(false);
        try {
          DirectoryReader reader = (s == null) ? null : s.get().getIndexReader();
          if (reader != null
              && reader.getIndexCommit() != null
              && reader.getIndexCommit().getGeneration() != 1L) {
            try {
              if (replicateOnOptimize) {
                Collection<IndexCommit> commits = DirectoryReader.listCommits(reader.directory());
                for (IndexCommit ic : commits) {
                  if (ic.getSegmentCount() == 1) {
                    if (indexCommitPoint == null
                        || indexCommitPoint.getGeneration() < ic.getGeneration())
                      indexCommitPoint = ic;
                  }
                }
              } else {
                indexCommitPoint = reader.getIndexCommit();
              }
            } finally {
              // We don't need to save commit points for replication, the SolrDeletionPolicy
              // always saves the last commit point (and the last optimized commit point, if needed)
              /*
              if(indexCommitPoint != null){
               core.getDeletionPolicy().saveCommitPoint(indexCommitPoint.getGeneration());
              }
              */
            }
          }

          // ensure the writer is initialized so that we have a list of commit points
          RefCounted<IndexWriter> iw =
              core.getUpdateHandler().getSolrCoreState().getIndexWriter(core);
          iw.decref();

        } catch (IOException e) {
          log.warn("Unable to get IndexCommit on startup", e);
        } finally {
          if (s != null) s.decref();
        }
      }
      isLeader = true;
    }

    {
      final String reserve = (String) initArgs.get(RESERVE);
      if (reserve != null && !reserve.trim().isEmpty()) {
        reserveCommitDuration = readIntervalMs(reserve);
      }
    }
    log.info("Commits will be reserved for {} ms", reserveCommitDuration);
  }