es 新增文档浅析

本文分析一下 es 写入文档，并同步到副本的一个过程，先阅读官方文档：https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-replication.html

Every indexing operation in Elasticsearch is first resolved to a replication group using routing, typically based on the document ID. 
Once the replication group has been determined, the operation is forwarded internally to the current primary shard of the group. 
This stage of indexing is referred to as the coordinating stage.

The next stage of indexing is the primary stage, performed on the primary shard. 
The primary shard is responsible for validating the operation and forwarding it to the other replicas. 
Since replicas can be offline, the primary is not required to replicate to all replicas. 
Instead, Elasticsearch maintains a list of shard copies that should receive the operation. 
This list is called the in-sync copies and is maintained by the master node. 
As the name implies, these are the set of "good" shard copies that are guaranteed to have processed all of the index and delete operations that have been acknowledged to the user. 
The primary is responsible for maintaining this invariant and thus has to replicate all operations to each copy in this set.

流程图如下：

 primary 写入文档的主要方法如下：

// org.elasticsearch.index.engine.InternalEngine#index
public IndexResult index(Index index) throws IOException {
    assert Objects.equals(index.uid().field(), IdFieldMapper.NAME) : index.uid().field();
    final boolean doThrottle = index.origin().isRecovery() == false;
    try (ReleasableLock releasableLock = readLock.acquire()) {
        ensureOpen();
        assert assertIncomingSequenceNumber(index.origin(), index.seqNo());
        int reservedDocs = 0;
        try (
            Releasable ignored = versionMap.acquireLock(index.uid().bytes());
            Releasable indexThrottle = doThrottle ? throttle.acquireThrottle() : () -> {}
        ) {
            lastWriteNanos = index.startTime();
            final IndexingStrategy plan = indexingStrategyForOperation(index);
            reservedDocs = plan.reservedDocs;

            final IndexResult indexResult;
            if (plan.earlyResultOnPreFlightError.isPresent()) {
                assert index.origin() == Operation.Origin.PRIMARY : index.origin();
                indexResult = plan.earlyResultOnPreFlightError.get();
                assert indexResult.getResultType() == Result.Type.FAILURE : indexResult.getResultType();
            } else {
                // generate or register sequence number
                if (index.origin() == Operation.Origin.PRIMARY) {
                    index = new Index(
                        index.uid(),
                        index.parsedDoc(),
                        generateSeqNoForOperationOnPrimary(index),
                        index.primaryTerm(),
                        index.version(),
                        index.versionType(),
                        index.origin(),
                        index.startTime(),
                        index.getAutoGeneratedIdTimestamp(),
                        index.isRetry(),
                        index.getIfSeqNo(),
                        index.getIfPrimaryTerm()
                    );

                    final boolean toAppend = plan.indexIntoLucene && plan.useLuceneUpdateDocument == false;
                    if (toAppend == false) {
                        advanceMaxSeqNoOfUpdatesOnPrimary(index.seqNo());
                    }
                } else {
                    markSeqNoAsSeen(index.seqNo());
                }

                assert index.seqNo() >= 0 : "ops should have an assigned seq no.; origin: " + index.origin();

                if (plan.indexIntoLucene || plan.addStaleOpToLucene) {
                    indexResult = indexIntoLucene(index, plan);
                } else {
                    indexResult = new IndexResult(
                        plan.versionForIndexing,
                        index.primaryTerm(),
                        index.seqNo(),
                        plan.currentNotFoundOrDeleted,
                        index.id()
                    );
                }
            }
            if (index.origin().isFromTranslog() == false) {
                final Translog.Location location;
                if (indexResult.getResultType() == Result.Type.SUCCESS) {
                    location = translog.add(new Translog.Index(index, indexResult));
                } else if (indexResult.getSeqNo() != SequenceNumbers.UNASSIGNED_SEQ_NO) {
                    // if we have document failure, record it as a no-op in the translog and Lucene with the generated seq_no
                    final NoOp noOp = new NoOp(
                        indexResult.getSeqNo(),
                        index.primaryTerm(),
                        index.origin(),
                        index.startTime(),
                        indexResult.getFailure().toString()
                    );
                    location = innerNoOp(noOp).getTranslogLocation();
                } else {
                    location = null;
                }
                indexResult.setTranslogLocation(location);
            }
            if (plan.indexIntoLucene && indexResult.getResultType() == Result.Type.SUCCESS) {
                final Translog.Location translogLocation = trackTranslogLocation.get() ? indexResult.getTranslogLocation() : null;
                versionMap.maybePutIndexUnderLock(
                    index.uid().bytes(),
                    new IndexVersionValue(translogLocation, plan.versionForIndexing, index.seqNo(), index.primaryTerm())
                );
            }
            localCheckpointTracker.markSeqNoAsProcessed(indexResult.getSeqNo());
            if (indexResult.getTranslogLocation() == null) {
                // the op is coming from the translog (and is hence persisted already) or it does not have a sequence number
                assert index.origin().isFromTranslog() || indexResult.getSeqNo() == SequenceNumbers.UNASSIGNED_SEQ_NO;
                localCheckpointTracker.markSeqNoAsPersisted(indexResult.getSeqNo());
            }
            indexResult.setTook(System.nanoTime() - index.startTime());
            indexResult.freeze();
            return indexResult;
        } finally {
            releaseInFlightDocs(reservedDocs);
        }
    } catch (RuntimeException | IOException e) {
        try {
            if (e instanceof AlreadyClosedException == false && treatDocumentFailureAsTragicError(index)) {
                failEngine("index id[" + index.id() + "] origin[" + index.origin() + "] seq#[" + index.seqNo() + "]", e);
            } else {
                maybeFailEngine("index id[" + index.id() + "] origin[" + index.origin() + "] seq#[" + index.seqNo() + "]", e);
            }
        } catch (Exception inner) {
            e.addSuppressed(inner);
        }
        throw e;
    }
}

第 51 行写入 lucene，第 65 行记录 translog。

主分片写入本地后，把数据同步到副本，代码如下：

// org.elasticsearch.action.support.replication.ReplicationOperation#performOnReplicas
private void performOnReplicas(
    final ReplicaRequest replicaRequest,
    final long globalCheckpoint,
    final long maxSeqNoOfUpdatesOrDeletes,
    final ReplicationGroup replicationGroup,
    final PendingReplicationActions pendingReplicationActions
) {
    // for total stats, add number of unassigned shards and
    // number of initializing shards that are not ready yet to receive operations (recovery has not opened engine yet on the target)
    totalShards.addAndGet(replicationGroup.getSkippedShards().size());

    final ShardRouting primaryRouting = primary.routingEntry();

    for (final ShardRouting shard : replicationGroup.getReplicationTargets()) {
        if (shard.isSameAllocation(primaryRouting) == false) {
            performOnReplica(shard, replicaRequest, globalCheckpoint, maxSeqNoOfUpdatesOrDeletes, pendingReplicationActions);
        }
    }
}