private bool? ReplicateDocuments(ReplicationStrategy destination, SourceReplicationInformationWithBatchInformation destinationsReplicationInformationForSource, ReplicationStatisticsRecorder.ReplicationStatisticsRecorderScope recorder, out int replicatedDocuments)
{
replicatedDocuments = 0;
JsonDocumentsToReplicate documentsToReplicate = null;
var sp = Stopwatch.StartNew();
IDisposable removeBatch = null;
var prefetchingBehavior = prefetchingBehaviors.GetOrAdd(destination.ConnectionStringOptions.Url,
x => docDb.Prefetcher.CreatePrefetchingBehavior(PrefetchingUser.Replicator, autoTuner, string.Format("Replication for URL: {0}" ,destination.ConnectionStringOptions.DefaultDatabase) ));
prefetchingBehavior.AdditionalInfo = string.Format("For destination: {0}. Last replicated etag: {1}", destination.ConnectionStringOptions.Url, destinationsReplicationInformationForSource.LastDocumentEtag);
try
{
using (var scope = recorder.StartRecording("Get"))
{
documentsToReplicate = GetJsonDocuments(destinationsReplicationInformationForSource, destination, prefetchingBehavior, scope);
if (documentsToReplicate.Documents == null || documentsToReplicate.Documents.Length == 0)
{
if (documentsToReplicate.LastEtag != destinationsReplicationInformationForSource.LastDocumentEtag)
{
// we don't notify remote server about updates to system docs, see: RavenDB-715
if (documentsToReplicate.CountOfFilteredDocumentsWhichAreSystemDocuments == 0
|| documentsToReplicate.CountOfFilteredDocumentsWhichAreSystemDocuments > SystemDocsLimitForRemoteEtagUpdate
|| documentsToReplicate.CountOfFilteredDocumentsWhichOriginFromDestination > DestinationDocsLimitForRemoteEtagUpdate) // see RavenDB-1555
{
using (scope.StartRecording("Notify"))
{
SetLastReplicatedEtagForServer(destination, lastDocEtag: documentsToReplicate.LastEtag);
scope.Record(new RavenJObject
{
{ "LastDocEtag", documentsToReplicate.LastEtag.ToString() }
});
}
}
}
RecordLastEtagChecked(destination.ConnectionStringOptions.Url, documentsToReplicate.LastEtag);
return null;
}
}
// if the db is idling in all respect except sending out replication, let us keep it that way.
docDb.WorkContext.UpdateFoundWork();
removeBatch = prefetchingBehavior.UpdateCurrentlyUsedBatches(documentsToReplicate.LoadedDocs);
using (var scope = recorder.StartRecording("Send"))
{
string lastError;
if (TryReplicationDocuments(destination, documentsToReplicate.Documents, out lastError) == false) // failed to replicate, start error handling strategy
{
if (IsFirstFailure(destination.ConnectionStringOptions.Url))
{
log.Info(
"This is the first failure for {0}, assuming transient failure and trying again",
destination);
if (TryReplicationDocuments(destination, documentsToReplicate.Documents, out lastError)) // success on second fail
{
RecordSuccess(destination.ConnectionStringOptions.Url, documentsToReplicate.LastEtag, documentsToReplicate.LastLastModified);
return true;
}
}
// if we had an error sending to this endpoint, it might be because we are sending too much data, or because
// the request timed out. This will let us know that the next time we try, we'll use just the initial doc counts
// and we'll be much more conservative with increasing the sizes
prefetchingBehavior.OutOfMemoryExceptionHappened();
scope.RecordError(lastError);
RecordFailure(destination.ConnectionStringOptions.Url, lastError);
return false;
}
}
}
finally
{
if (documentsToReplicate != null && documentsToReplicate.LoadedDocs != null)
{
prefetchingBehavior.UpdateAutoThrottler(documentsToReplicate.LoadedDocs, sp.Elapsed);
replicatedDocuments = documentsToReplicate.LoadedDocs.Count;
}
if (removeBatch != null)
removeBatch.Dispose();
}
RecordSuccess(destination.ConnectionStringOptions.Url, documentsToReplicate.LastEtag, documentsToReplicate.LastLastModified);
return true;
}
private bool? ReplicateAttachments(ReplicationStrategy destination, SourceReplicationInformationWithBatchInformation destinationsReplicationInformationForSource, ReplicationStatisticsRecorder.ReplicationStatisticsRecorderScope recorder)
{
Tuple<RavenJArray, Etag> tuple;
RavenJArray attachments;
using (var scope = recorder.StartRecording("Get"))
{
tuple = GetAttachments(destinationsReplicationInformationForSource, destination, scope);
attachments = tuple.Item1;
if (attachments == null || attachments.Length == 0)
{
if (tuple.Item2 != destinationsReplicationInformationForSource.LastAttachmentEtag)
{
SetLastReplicatedEtagForServer(destination, lastAttachmentEtag: tuple.Item2);
}
return null;
}
}
using (var scope = recorder.StartRecording("Send"))
{
string lastError;
if (TryReplicationAttachments(destination, attachments, out lastError) == false) // failed to replicate, start error handling strategy
{
if (IsFirstFailure(destination.ConnectionStringOptions.Url))
{
log.Info("This is the first failure for {0}, assuming transient failure and trying again", destination);
if (TryReplicationAttachments(destination, attachments, out lastError)) // success on second fail
{
RecordSuccess(destination.ConnectionStringOptions.Url, lastReplicatedEtag: tuple.Item2, forDocuments:false);
return true;
}
}
scope.RecordError(lastError);
RecordFailure(destination.ConnectionStringOptions.Url, lastError);
return false;
}
}
RecordSuccess(destination.ConnectionStringOptions.Url,
lastReplicatedEtag: tuple.Item2, forDocuments: false);
return true;
}
private JsonDocumentsToReplicate GetJsonDocuments(SourceReplicationInformationWithBatchInformation destinationsReplicationInformationForSource, ReplicationStrategy destination, PrefetchingBehavior prefetchingBehavior, ReplicationStatisticsRecorder.ReplicationStatisticsRecorderScope scope)
{
var timeout = TimeSpan.FromSeconds(docDb.Configuration.Replication.FetchingFromDiskTimeoutInSeconds);
var duration = Stopwatch.StartNew();
var result = new JsonDocumentsToReplicate
{
LastEtag = Etag.Empty,
};
try
{
var destinationId = destinationsReplicationInformationForSource.ServerInstanceId.ToString();
var maxNumberOfItemsToReceiveInSingleBatch = destinationsReplicationInformationForSource.MaxNumberOfItemsToReceiveInSingleBatch;
docDb.TransactionalStorage.Batch(actions =>
{
var lastEtag = destinationsReplicationInformationForSource.LastDocumentEtag;
int docsSinceLastReplEtag = 0;
List<JsonDocument> docsToReplicate;
List<JsonDocument> filteredDocsToReplicate;
result.LastEtag = lastEtag;
while (true)
{
docDb.WorkContext.CancellationToken.ThrowIfCancellationRequested();
docsToReplicate = GetDocsToReplicate(actions, prefetchingBehavior, result, maxNumberOfItemsToReceiveInSingleBatch);
filteredDocsToReplicate =
docsToReplicate
.Where(document =>
{
var info = docDb.Documents.GetRecentTouchesFor(document.Key);
if (info != null)
{
if (info.TouchedEtag.CompareTo(result.LastEtag) > 0)
{
log.Debug(
"Will not replicate document '{0}' to '{1}' because the updates after etag {2} are related document touches",
document.Key, destinationId, info.TouchedEtag);
return false;
}
}
string reason;
return destination.FilterDocuments(destinationId, document.Key, document.Metadata, out reason) &&
prefetchingBehavior.FilterDocuments(document);
})
.ToList();
docsSinceLastReplEtag += docsToReplicate.Count;
result.CountOfFilteredDocumentsWhichAreSystemDocuments +=
docsToReplicate.Count(doc => destination.IsSystemDocumentId(doc.Key));
result.CountOfFilteredDocumentsWhichOriginFromDestination +=
docsToReplicate.Count(doc => destination.OriginsFromDestination(destinationId, doc.Metadata));
if (docsToReplicate.Count > 0)
{
var lastDoc = docsToReplicate.Last();
Debug.Assert(lastDoc.Etag != null);
result.LastEtag = lastDoc.Etag;
if (lastDoc.LastModified.HasValue)
result.LastLastModified = lastDoc.LastModified.Value;
}
if (docsToReplicate.Count == 0 || filteredDocsToReplicate.Count != 0)
{
break;
}
log.Debug("All the docs were filtered, trying another batch from etag [>{0}]", result.LastEtag);
if (duration.Elapsed > timeout)
break;
}
log.Debug(() =>
{
if (docsSinceLastReplEtag == 0)
return string.Format("No documents to replicate to {0} - last replicated etag: {1}", destination,
lastEtag);
if (docsSinceLastReplEtag == filteredDocsToReplicate.Count)
return string.Format("Replicating {0} docs [>{1}] to {2}.",
docsSinceLastReplEtag,
lastEtag,
destination);
var diff = docsToReplicate.Except(filteredDocsToReplicate).Select(x => x.Key);
return string.Format("Replicating {1} docs (out of {0}) [>{4}] to {2}. [Not replicated: {3}]",
docsSinceLastReplEtag,
filteredDocsToReplicate.Count,
destination,
string.Join(", ", diff),
lastEtag);
});
scope.Record(new RavenJObject
{
{"StartEtag", lastEtag.ToString()},
{"EndEtag", result.LastEtag.ToString()},
{"Count", docsSinceLastReplEtag},
{"FilteredCount", filteredDocsToReplicate.Count}
});
result.LoadedDocs = filteredDocsToReplicate;
docDb.WorkContext.MetricsCounters.GetReplicationBatchSizeMetric(destination).Mark(docsSinceLastReplEtag);
docDb.WorkContext.MetricsCounters.GetReplicationBatchSizeHistogram(destination).Update(docsSinceLastReplEtag);
result.Documents = new RavenJArray(filteredDocsToReplicate
.Select(x =>
{
JsonDocument.EnsureIdInMetadata(x);
EnsureReplicationInformationInMetadata(x.Metadata, docDb);
return x;
})
.Select(x => x.ToJson()));
});
}
catch (Exception e)
{
scope.RecordError(e);
log.WarnException(
"Could not get documents to replicate after: " +
destinationsReplicationInformationForSource.LastDocumentEtag, e);
}
return result;
}
private Tuple<RavenJArray, Etag> GetAttachments(SourceReplicationInformationWithBatchInformation destinationsReplicationInformationForSource, ReplicationStrategy destination, ReplicationStatisticsRecorder.ReplicationStatisticsRecorderScope scope)
{
var timeout = TimeSpan.FromSeconds(docDb.Configuration.Replication.FetchingFromDiskTimeoutInSeconds);
var duration = Stopwatch.StartNew();
RavenJArray attachments = null;
Etag lastAttachmentEtag = Etag.Empty;
try
{
var destinationId = destinationsReplicationInformationForSource.ServerInstanceId.ToString();
var maxNumberOfItemsToReceiveInSingleBatch = destinationsReplicationInformationForSource.MaxNumberOfItemsToReceiveInSingleBatch;
docDb.TransactionalStorage.Batch(actions =>
{
int attachmentSinceLastEtag = 0;
List<AttachmentInformation> attachmentsToReplicate;
List<AttachmentInformation> filteredAttachmentsToReplicate;
var startEtag = destinationsReplicationInformationForSource.LastAttachmentEtag;
lastAttachmentEtag = startEtag;
while (true)
{
attachmentsToReplicate = GetAttachmentsToReplicate(actions, lastAttachmentEtag, maxNumberOfItemsToReceiveInSingleBatch);
filteredAttachmentsToReplicate = attachmentsToReplicate.Where(attachment => destination.FilterAttachments(attachment, destinationId)).ToList();
attachmentSinceLastEtag += attachmentsToReplicate.Count;
if (attachmentsToReplicate.Count == 0 ||
filteredAttachmentsToReplicate.Count != 0)
{
break;
}
AttachmentInformation jsonDocument = attachmentsToReplicate.Last();
Etag attachmentEtag = jsonDocument.Etag;
log.Debug("All the attachments were filtered, trying another batch from etag [>{0}]", attachmentEtag);
lastAttachmentEtag = attachmentEtag;
if (duration.Elapsed > timeout)
break;
}
log.Debug(() =>
{
if (attachmentSinceLastEtag == 0)
return string.Format("No attachments to replicate to {0} - last replicated etag: {1}", destination,
destinationsReplicationInformationForSource.LastAttachmentEtag);
if (attachmentSinceLastEtag == filteredAttachmentsToReplicate.Count)
return string.Format("Replicating {0} attachments [>{1}] to {2}.",
attachmentSinceLastEtag,
destinationsReplicationInformationForSource.LastAttachmentEtag,
destination);
var diff = attachmentsToReplicate.Except(filteredAttachmentsToReplicate).Select(x => x.Key);
return string.Format("Replicating {1} attachments (out of {0}) [>{4}] to {2}. [Not replicated: {3}]",
attachmentSinceLastEtag,
filteredAttachmentsToReplicate.Count,
destination,
string.Join(", ", diff),
destinationsReplicationInformationForSource.LastAttachmentEtag);
});
scope.Record(new RavenJObject
{
{"StartEtag", startEtag.ToString()},
{"EndEtag", lastAttachmentEtag.ToString()},
{"Count", attachmentSinceLastEtag},
{"FilteredCount", filteredAttachmentsToReplicate.Count}
});
attachments = new RavenJArray(filteredAttachmentsToReplicate
.Select(x =>
{
var data = new byte[0];
if (x.Size > 0)
{
data = actions.Attachments.GetAttachment(x.Key).Data().ReadData();
}
EnsureReplicationInformationInMetadata(x.Metadata, docDb);
return new RavenJObject
{
{"@metadata", x.Metadata},
{"@id", x.Key},
{"@etag", x.Etag.ToByteArray()},
{"data", data}
};
}));
});
}
catch (InvalidDataException e)
{
RecordFailure(String.Empty, string.Format("Data is corrupted, could not proceed with attachment replication. Exception : {0}", e));
scope.RecordError(e);
log.ErrorException("Data is corrupted, could not proceed with replication", e);
}
catch (Exception e)
{
log.WarnException("Could not get attachments to replicate after: " + destinationsReplicationInformationForSource.LastAttachmentEtag, e);
}
return Tuple.Create(attachments, lastAttachmentEtag);
}
public HttpResponseMessage ReplicationLastEtagGet()
{
string src;
string dbid;
var result = GetValuesForLastEtag(out src, out dbid);
if (result != null)
return result;
using (Database.DisableAllTriggersForCurrentThread())
{
JsonDocument document = null;
SourceReplicationInformationWithBatchInformation sourceReplicationInformation = null;
var localServerInstanceId = Database.TransactionalStorage.Id; // this is my id, sent to the remote server
if (string.IsNullOrEmpty(dbid))
{
// backward compatibility for replication behavior
int nextStart = 0;
var replicationSources = Database.Documents.GetDocumentsWithIdStartingWith(Constants.RavenReplicationSourcesBasePath, null, null, 0, int.MaxValue, CancellationToken.None, ref nextStart);
foreach (RavenJObject replicationSource in replicationSources)
{
sourceReplicationInformation = replicationSource.JsonDeserialization<SourceReplicationInformationWithBatchInformation>();
if (string.Equals(sourceReplicationInformation.Source, src, StringComparison.OrdinalIgnoreCase) == false)
continue;
document = replicationSource.ToJsonDocument();
break;
}
}
else
{
var remoteServerInstanceId = Guid.Parse(dbid);
document = Database.Documents.Get(Constants.RavenReplicationSourcesBasePath + "/" + remoteServerInstanceId, null);
if (document == null)
{
// migrate
document = Database.Documents.Get(Constants.RavenReplicationSourcesBasePath + "/" + src, null);
if (document != null)
{
sourceReplicationInformation = document.DataAsJson.JsonDeserialization<SourceReplicationInformationWithBatchInformation>();
Database.Documents.Put(Constants.RavenReplicationSourcesBasePath + "/" + sourceReplicationInformation.ServerInstanceId, Etag.Empty, document.DataAsJson, document.Metadata, null);
Database.Documents.Delete(Constants.RavenReplicationSourcesBasePath + "/" + src, document.Etag, null);
if (remoteServerInstanceId != sourceReplicationInformation.ServerInstanceId)
document = null;
}
}
}
if (document == null)
{
sourceReplicationInformation = new SourceReplicationInformationWithBatchInformation
{
Source = src,
ServerInstanceId = localServerInstanceId,
LastModified = SystemTime.UtcNow
};
}
else
{
if (sourceReplicationInformation == null)
sourceReplicationInformation = document.DataAsJson.JsonDeserialization<SourceReplicationInformationWithBatchInformation>();
if (string.Equals(sourceReplicationInformation.Source, src, StringComparison.OrdinalIgnoreCase) == false
&& sourceReplicationInformation.LastModified.HasValue
&& (SystemTime.UtcNow - sourceReplicationInformation.LastModified.Value).TotalMinutes < 10)
{
log.Info(string.Format("Replication source mismatch. Stored: {0}. Remote: {1}.", sourceReplicationInformation.Source, src));
sourceReplicationInformation.LastAttachmentEtag = Etag.InvalidEtag;
sourceReplicationInformation.LastDocumentEtag = Etag.InvalidEtag;
}
sourceReplicationInformation.ServerInstanceId = localServerInstanceId;
}
var maxNumberOfItemsToReceiveInSingleBatch = Database.Configuration.Replication.MaxNumberOfItemsToReceiveInSingleBatch;
var availableMemory = MemoryStatistics.AvailableMemory;
var lowMemory = availableMemory < 0.2 * MemoryStatistics.TotalPhysicalMemory && availableMemory < Database.Configuration.AvailableMemoryForRaisingBatchSizeLimit * 2;
if (lowMemory)
{
int size;
var lastBatchSize = sourceReplicationInformation.LastBatchSize;
if (lastBatchSize.HasValue && maxNumberOfItemsToReceiveInSingleBatch.HasValue)
size = Math.Min(lastBatchSize.Value, maxNumberOfItemsToReceiveInSingleBatch.Value);
else if (lastBatchSize.HasValue)
size = lastBatchSize.Value;
else if (maxNumberOfItemsToReceiveInSingleBatch.HasValue)
size = maxNumberOfItemsToReceiveInSingleBatch.Value;
else
size = 128;
sourceReplicationInformation.MaxNumberOfItemsToReceiveInSingleBatch =
Math.Max(size / 2, 64);
}
else
{
sourceReplicationInformation.MaxNumberOfItemsToReceiveInSingleBatch = Database.Configuration.Replication.MaxNumberOfItemsToReceiveInSingleBatch;
}
var currentEtag = GetQueryStringValue("currentEtag");
Log.Debug(() => string.Format("Got replication last etag request from {0}: [Local: {1} Remote: {2}]. LowMemory: {3}. MaxNumberOfItemsToReceiveInSingleBatch: {4}.", src, sourceReplicationInformation.LastDocumentEtag, currentEtag, lowMemory, sourceReplicationInformation.MaxNumberOfItemsToReceiveInSingleBatch));
return GetMessageWithObject(sourceReplicationInformation);
}
}
