org.apache.solr.update.UpdateLog Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of solr-core Show documentation
Apache Solr (module: core)
There is a newer version: 9.7.0
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.solr.update;

import static org.apache.solr.update.processor.DistributedUpdateProcessor.DistribPhase.FROMLEADER;
import static org.apache.solr.update.processor.DistributingUpdateProcessorFactory.DISTRIB_UPDATE_PARAM;

import com.carrotsearch.hppc.LongHashSet;
import com.carrotsearch.hppc.LongSet;
import com.codahale.metrics.Gauge;
import com.codahale.metrics.Meter;
import java.io.Closeable;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.lang.invoke.MethodHandles;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.Future;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Stream;
import org.apache.lucene.util.BytesRef;
import org.apache.solr.common.SolrDocumentBase;
import org.apache.solr.common.SolrException;
import org.apache.solr.common.SolrException.ErrorCode;
import org.apache.solr.common.SolrInputDocument;
import org.apache.solr.common.params.ModifiableSolrParams;
import org.apache.solr.common.params.SolrParams;
import org.apache.solr.common.util.CollectionUtil;
import org.apache.solr.common.util.ExecutorUtil;
import org.apache.solr.common.util.IOUtils;
import org.apache.solr.common.util.SolrNamedThreadFactory;
import org.apache.solr.common.util.SuppressForbidden;
import org.apache.solr.common.util.TimeSource;
import org.apache.solr.core.PluginInfo;
import org.apache.solr.core.SolrCore;
import org.apache.solr.core.SolrInfoBean;
import org.apache.solr.metrics.SolrMetricProducer;
import org.apache.solr.metrics.SolrMetricsContext;
import org.apache.solr.request.LocalSolrQueryRequest;
import org.apache.solr.request.SolrQueryRequest;
import org.apache.solr.request.SolrRequestInfo;
import org.apache.solr.response.SolrQueryResponse;
import org.apache.solr.search.SolrIndexSearcher;
import org.apache.solr.update.processor.DistributedUpdateProcessor;
import org.apache.solr.update.processor.UpdateRequestProcessor;
import org.apache.solr.update.processor.UpdateRequestProcessorChain;
import org.apache.solr.util.OrderedExecutor;
import org.apache.solr.util.RefCounted;
import org.apache.solr.util.TestInjection;
import org.apache.solr.util.TimeOut;
import org.apache.solr.util.plugin.PluginInfoInitialized;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * This holds references to the transaction logs. It also keeps a map of unique key to location in
 * log (along with the update's version). This map is only cleared on soft or hard commit
 *
 * @lucene.experimental
 */
public class UpdateLog implements PluginInfoInitialized, SolrMetricProducer {
  private static final long STATUS_TIME = TimeUnit.NANOSECONDS.convert(60, TimeUnit.SECONDS);
  public static String LOG_FILENAME_PATTERN = "%s.%019d";
  public static String TLOG_NAME = "tlog";
  public static String BUFFER_TLOG_NAME = "buffer.tlog";

  private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
  private boolean debug = log.isDebugEnabled();
  private boolean trace = log.isTraceEnabled();
  private boolean usableForChildDocs;

  public enum SyncLevel {
    NONE,
    FLUSH,
    FSYNC;

    public static SyncLevel getSyncLevel(String level) {
      if (level == null) {
        return SyncLevel.FLUSH;
      }
      try {
        return SyncLevel.valueOf(level.toUpperCase(Locale.ROOT));
      } catch (Exception ex) {
        log.warn("There was an error reading the SyncLevel - default to {}", SyncLevel.FLUSH, ex);
        return SyncLevel.FLUSH;
      }
    }
  }

  // NOTE: when adding new states make sure to keep existing numbers, because external metrics
  // monitoring may depend on these values being stable.
  public enum State {
    REPLAYING(0),
    BUFFERING(1),
    APPLYING_BUFFERED(2),
    ACTIVE(3);
    private final int value;

    State(final int value) {
      this.value = value;
    }

    public int getValue() {
      return value;
    }
  }

  public static final int ADD = 0x01;
  public static final int DELETE = 0x02;
  public static final int DELETE_BY_QUERY = 0x03;
  public static final int COMMIT = 0x04;
  public static final int UPDATE_INPLACE = 0x08;
  // For backward-compatibility, we should delete this field in 9.0
  public static final int OPERATION_MASK = 0x0f; // mask off flags to get the operation

  /** The index of the flags value in an entry from the transaction log. */
  public static final int FLAGS_IDX = 0;

  /** The index of the _version_ value in an entry from the transaction log. */
  public static final int VERSION_IDX = 1;

  /**
   * The index of the previous pointer in an entry from the transaction log. This is only relevant
   * if flags (indexed at FLAGS_IDX) includes UPDATE_INPLACE.
   */
  public static final int PREV_POINTER_IDX = 2;

  /**
   * The index of the previous version in an entry from the transaction log. This is only relevant
   * if flags (indexed at FLAGS_IDX) includes UPDATE_INPLACE.
   */
  public static final int PREV_VERSION_IDX = 3;

  public static class RecoveryInfo {
    public long positionOfStart;

    public int adds;
    public int deletes;
    public int deleteByQuery;
    public AtomicInteger errors = new AtomicInteger(0);

    public boolean failed;

    @Override
    public String toString() {
      return "RecoveryInfo{adds="
          + adds
          + " deletes="
          + deletes
          + " deleteByQuery="
          + deleteByQuery
          + " errors="
          + errors
          + " positionOfStart="
          + positionOfStart
          + "}";
    }
  }

  protected long id = -1;
  protected volatile State state = State.ACTIVE;

  protected TransactionLog bufferTlog;
  protected TransactionLog tlog;
  protected TransactionLog prevTlog;
  protected TransactionLog prevTlogOnPrecommit;
  // list of recent logs, newest first
  protected final Deque logs = new ArrayDeque<>();
  protected Deque newestLogsOnStartup = new ArrayDeque<>();
  protected int numOldRecords; // number of records in the recent logs

  protected Map map = new HashMap<>();
  protected Map prevMap; // used while committing/reopening is happening
  protected Map prevMap2; // used while committing/reopening is happening
  // the transaction log used to look up entries found in prevMap
  protected TransactionLog prevMapLog;
  // the transaction log used to look up entries found in prevMap2
  protected TransactionLog prevMapLog2;

  protected final int numDeletesToKeep = 1000;
  protected final int numDeletesByQueryToKeep = 100;
  protected int numRecordsToKeep;
  protected int maxNumLogsToKeep;
  // This should only be used to initialize VersionInfo... the actual number of buckets may be
  // rounded up to a power of two.
  protected int numVersionBuckets;
  protected boolean existOldBufferLog = false;

  // keep track of deletes only... this is not updated on an add
  protected LinkedHashMap oldDeletes =
      new OldDeletesLinkedHashMap(this.numDeletesToKeep);

  /** Holds the query and the version for a DeleteByQuery command */
  public static class DBQ {
    public String q; // the query string
    public long version; // positive version of the DBQ

    @Override
    public String toString() {
      return "DBQ{version=" + version + ",q=" + q + "}";
    }
  }

  @SuppressWarnings("JdkObsolete")
  protected LinkedList deleteByQueries = new LinkedList<>();

  // Needs to be String because hdfs.Path is incompatible with nio.Path
  protected String[] tlogFiles;
  protected Path tlogDir;
  protected Collection globalStrings;

  protected String dataDir;
  protected String lastDataDir;

  protected VersionInfo versionInfo;

  protected SyncLevel defaultSyncLevel = SyncLevel.FLUSH;

  protected volatile UpdateHandler uhandler; // a core reload can change this reference!
  protected volatile boolean cancelApplyBufferUpdate;
  protected List startingVersions;

  // metrics
  protected Gauge bufferedOpsGauge;
  protected Meter applyingBufferedOpsMeter;
  protected Meter replayOpsMeter;
  protected Meter copyOverOldUpdatesMeter;
  protected SolrMetricsContext solrMetricsContext;

  public static class LogPtr {
    final long pointer;
    final long version;
    // used for entries that are in-place updates and need a pointer to a previous update command
    final long previousPointer;

    /**
     * Creates an object that contains the position and version of an update. In this constructor,
     * the effective value of the previousPointer is -1.
     *
     * @param pointer Position in the transaction log of an update
     * @param version Version of the update at the given position
     */
    public LogPtr(long pointer, long version) {
      this(pointer, version, -1);
    }

    /**
     * @param pointer Position in the transaction log of an update
     * @param version Version of the update at the given position
     * @param previousPointer Position, in the transaction log, of an update on which the current
     *     update depends
     */
    public LogPtr(long pointer, long version, long previousPointer) {
      this.pointer = pointer;
      this.version = version;
      this.previousPointer = previousPointer;
    }

    @Override
    public String toString() {
      return "LogPtr(" + pointer + ")";
    }
  }

  public long getTotalLogsSize() {
    long size = 0;
    synchronized (this) {
      for (TransactionLog log : logs) {
        size += log.getLogSize();
      }
    }
    return size;
  }

  /**
   * @return the current transaction log's size (based on its output stream)
   */
  public synchronized long getCurrentLogSizeFromStream() {
    return tlog == null ? 0 : tlog.getLogSizeFromStream();
  }

  public long getTotalLogsNumber() {
    synchronized (this) {
      return logs.size();
    }
  }

  public VersionInfo getVersionInfo() {
    return versionInfo;
  }

  public int getNumRecordsToKeep() {
    return numRecordsToKeep;
  }

  public int getMaxNumLogsToKeep() {
    return maxNumLogsToKeep;
  }

  public int getNumVersionBuckets() {
    return numVersionBuckets;
  }

  protected static int objToInt(Object obj, int def) {
    if (obj != null) {
      return Integer.parseInt(obj.toString());
    } else return def;
  }

  @Override
  public void init(PluginInfo info) {
    dataDir = (String) info.initArgs.get("dir");
    defaultSyncLevel = SyncLevel.getSyncLevel((String) info.initArgs.get("syncLevel"));

    numRecordsToKeep = objToInt(info.initArgs.get("numRecordsToKeep"), 100);
    maxNumLogsToKeep = objToInt(info.initArgs.get("maxNumLogsToKeep"), 10);
    numVersionBuckets = objToInt(info.initArgs.get("numVersionBuckets"), 65536);
    if (numVersionBuckets <= 0)
      throw new SolrException(
          SolrException.ErrorCode.SERVER_ERROR,
          "Number of version buckets must be greater than 0!");

    log.info(
        "Initializing UpdateLog: dataDir={} defaultSyncLevel={} numRecordsToKeep={} maxNumLogsToKeep={} numVersionBuckets={}",
        dataDir,
        defaultSyncLevel,
        numRecordsToKeep,
        maxNumLogsToKeep,
        numVersionBuckets);
  }

  /* Note, when this is called, uhandler is not completely constructed.
   * This must be called when a new log is created, or
   * for an existing log whenever the core or update handler changes.
   */
  public void init(UpdateHandler uhandler, SolrCore core) {
    dataDir = core.getUlogDir();

    this.uhandler = uhandler;

    usableForChildDocs = core.getLatestSchema().isUsableForChildDocs();

    if (dataDir.equals(lastDataDir)) {
      versionInfo.reload();
      core.getCoreMetricManager()
          .registerMetricProducer(SolrInfoBean.Category.TLOG.toString(), this);

      if (debug) {
        log.debug(
            "UpdateHandler init: tlogDir={}, next id={} this is a reopen...nothing else to do",
            tlogDir,
            id);
      }
      return;
    }
    lastDataDir = dataDir;
    tlogDir = Path.of(dataDir, TLOG_NAME);
    try {
      Files.createDirectories(tlogDir);
    } catch (IOException e) {
      throw new SolrException(ErrorCode.SERVER_ERROR, "Could not set up tlogs", e);
    }
    tlogFiles = getLogList(tlogDir.toFile());
    id = getLastLogId() + 1; // add 1 since we will create a new log for the next update

    if (debug) {
      log.debug(
          "UpdateHandler init: tlogDir={}, existing tlogs={}, next id={}",
          tlogDir,
          Arrays.asList(tlogFiles),
          id);
    }

    final String prefix = BUFFER_TLOG_NAME + '.';
    try (Stream bufferedTLogs = Files.walk(tlogDir, 1)) {
      existOldBufferLog =
          bufferedTLogs.anyMatch(path -> path.getFileName().toString().startsWith(prefix));
    } catch (IOException e) {
      // Existance of buffered t-logs indicates previous recovery failed and lets us skip peer sync
      // as an optimization. Failing to read them is non-fatal and almost not even worth logging
      // about
      log.debug(
          "Could not read {} directory searching for buffered transaction log files.", tlogDir, e);
      existOldBufferLog = false;
    }
    TransactionLog oldLog = null;
    for (String oldLogName : tlogFiles) {
      Path path = tlogDir.resolve(oldLogName);
      try {
        oldLog = newTransactionLog(path, null, true);
        // don't remove old logs on startup since more than one may be uncapped.
        addOldLog(oldLog, false);
      } catch (RuntimeException e) {
        // This could be a SolrException, why is it non-fatal?
        log.error("Failure to open existing log file (non fatal) {} ", path, e);
        deleteFile(path);
      }
    }

    // Record first two logs (oldest first) at startup for potential tlog recovery.
    // It's possible that at abnormal close both "tlog" and "prevTlog" were uncapped.
    for (TransactionLog ll : logs) {
      newestLogsOnStartup.addFirst(ll);
      if (newestLogsOnStartup.size() >= 2) break;
    }

    try {
      versionInfo = new VersionInfo(this, numVersionBuckets);
    } catch (SolrException e) {
      log.error("Unable to use updateLog: ", e);
      throw new SolrException(
          SolrException.ErrorCode.SERVER_ERROR, "Unable to use updateLog: " + e.getMessage(), e);
    }

    // TODO: these startingVersions assume that we successfully recover from all non-complete tlogs.
    try (RecentUpdates startingUpdates = getRecentUpdates()) {
      startingVersions = startingUpdates.getVersions(numRecordsToKeep);

      // populate recent deletes list (since we can't get that info from the index)
      for (int i = startingUpdates.deleteList.size() - 1; i >= 0; i--) {
        DeleteUpdate du = startingUpdates.deleteList.get(i);
        oldDeletes.put(new BytesRef(du.id), new LogPtr(-1, du.version));
      }

      // populate recent deleteByQuery commands
      for (int i = startingUpdates.deleteByQueryList.size() - 1; i >= 0; i--) {
        Update update = startingUpdates.deleteByQueryList.get(i);
        @SuppressWarnings({"unchecked"})
        List