private void OutgoingHandlerRemoved(OutgoingReplicationHandler handler) { if (_outgoing.TryRemove(handler, out var stats)) { stats.Handler.DocumentsSend -= OutgoingDocumentsSend; } }
private void OnOutgoingSendingFailed(OutgoingReplicationHandler instance, Exception e) { using (instance) { instance.Failed -= OnOutgoingSendingFailed; instance.SuccessfulTwoWaysCommunication -= OnOutgoingSendingSucceeded; _outgoing.TryRemove(instance); OutgoingReplicationRemoved?.Invoke(instance); if (_outgoingFailureInfo.TryGetValue(instance.Node, out ConnectionShutdownInfo failureInfo) == false) { return; } UpdateLastEtag(instance); failureInfo.OnError(e); failureInfo.DestinationDbId = instance.DestinationDbId; failureInfo.LastHeartbeatTicks = instance.LastHeartbeatTicks; _reconnectQueue.Add(failureInfo); if (_log.IsInfoEnabled) { _log.Info($"Document replication connection ({instance.Node}) failed, and the connection will be retried later.", e); } } }
public ReplicationIndexTransformerSender(Stream stream, OutgoingReplicationHandler parent, Logger log) { _log = log; _orderedReplicaItems = new SortedList <long, ReplicationBatchIndexItem>(); _stream = stream; _parent = parent; }
public ReplicationDocumentSender(Stream stream, OutgoingReplicationHandler parent, Logger log) { _log = log; _orderedReplicaItems = new SortedList <long, ReplicationBatchDocumentItem>(); _stream = stream; _parent = parent; }
private void OutgoingHandlerAdded(OutgoingReplicationHandler handler) { _outgoing.GetOrAdd(handler, key => { handler.DocumentsSend += OutgoingDocumentsSend; return(new ReplicationHandlerAndPerformanceStatsList <OutgoingReplicationHandler, OutgoingReplicationStatsAggregator>(handler)); }); }
private void UpdateLastEtag(OutgoingReplicationHandler instance) { var etagPerDestination = _lastSendEtagPerDestination.GetOrAdd( instance.Node, _ => new LastEtagPerDestination()); if (etagPerDestination.LastEtag == instance._lastSentDocumentEtag) { return; } Interlocked.Exchange(ref etagPerDestination.LastEtag, instance._lastSentDocumentEtag); }
private void OnOutgoingSendingSucceeded(OutgoingReplicationHandler instance) { UpdateLastEtag(instance); if (_outgoingFailureInfo.TryGetValue(instance.Node, out ConnectionShutdownInfo failureInfo)) { failureInfo.Reset(); } while (_waitForReplicationTasks.TryDequeue(out TaskCompletionSource <object> result)) { TaskExecutor.Complete(result); } }
private void AddAndStartOutgoingReplication(ReplicationDestination destination) { var outgoingReplication = new OutgoingReplicationHandler(_database, destination); outgoingReplication.Failed += OnOutgoingSendingFailed; outgoingReplication.SuccessfulTwoWaysCommunication += OnOutgoingSendingSucceeded; _outgoing.TryAdd(outgoingReplication); // can't fail, this is a brand new instance _outgoingFailureInfo.TryAdd(destination, new ConnectionFailureInfo { Destination = destination }); outgoingReplication.Start(); }
public ReplicationDocumentSender(Stream stream, OutgoingReplicationHandler parent, Logger log, string[] pathsToSend, string[] destinationAcceptablePaths) { _log = log; if (pathsToSend != null && pathsToSend.Length > 0) { _pathsToSend = new AllowedPathsValidator(pathsToSend); } if (destinationAcceptablePaths != null && destinationAcceptablePaths.Length > 0) { _destinationAcceptablePaths = new AllowedPathsValidator(destinationAcceptablePaths); } _stream = stream; _parent = parent; }
private void OnOutgoingSendingSucceeded(OutgoingReplicationHandler instance) { ConnectionFailureInfo failureInfo; if (_outgoingFailureInfo.TryGetValue(instance.Destination, out failureInfo)) { failureInfo.Reset(); } TaskCompletionSource <object> result; while (_waitForReplicationTasks.TryDequeue(out result)) { ThreadPool.QueueUserWorkItem(task => ((TaskCompletionSource <object>)task).TrySetResult(null), result); } }
private void OutgoingDocumentsSend(OutgoingReplicationHandler handler) { if (_outgoing.TryGetValue(handler, out var stats) == false) { // possible? return; } var latestStat = stats.Handler.GetLatestReplicationPerformance(); if (latestStat != null) { stats.Performance.Add(latestStat, _cts.Token); } }
public ReplicationDocumentSender(Stream stream, OutgoingReplicationHandler parent, Logger log, string[] pathsToSend, string[] destinationAcceptablePaths) { _log = log; if (pathsToSend != null && pathsToSend.Length > 0) { _pathsToSend = new AllowedPathsValidator(pathsToSend); } if (destinationAcceptablePaths != null && destinationAcceptablePaths.Length > 0) { _destinationAcceptablePaths = new AllowedPathsValidator(destinationAcceptablePaths); } _stream = stream; _parent = parent; _shouldSkipSendingTombstones = _parent.Destination is PullReplicationAsSink sink && sink.Mode == PullReplicationMode.SinkToHub && parent._outgoingPullReplicationParams?.PreventDeletionsMode?.HasFlag(PreventDeletionsMode.PreventSinkToHubDeletions) == true && _parent._database.ForTestingPurposes?.ForceSendTombstones == false; }
private void AddAndStartOutgoingReplication(ReplicationNode node, bool external) { var outgoingReplication = new OutgoingReplicationHandler(this, Database, node, external); outgoingReplication.Failed += OnOutgoingSendingFailed; outgoingReplication.SuccessfulTwoWaysCommunication += OnOutgoingSendingSucceeded; _outgoing.TryAdd(outgoingReplication); // can't fail, this is a brand new instance node.Url = node.Url.Trim(); _outgoingFailureInfo.TryAdd(node, new ConnectionShutdownInfo { Node = node, External = external }); outgoingReplication.Start(); OutgoingReplicationAdded?.Invoke(outgoingReplication); }
private void AddAndStartOutgoingReplication(ReplicationNode node, bool external) { var info = GetConnectionInfo(node, external); if (info == null) { // this means that we were unable to retrive the tcp connection info and will try it again later return; } var outgoingReplication = new OutgoingReplicationHandler(this, Database, node, external, info); outgoingReplication.Failed += OnOutgoingSendingFailed; outgoingReplication.SuccessfulTwoWaysCommunication += OnOutgoingSendingSucceeded; _outgoing.TryAdd(outgoingReplication); // can't fail, this is a brand new instance outgoingReplication.Start(); OutgoingReplicationAdded?.Invoke(outgoingReplication); }
private void OnOutgoingSendingFailed(OutgoingReplicationHandler instance, Exception e) { using (instance) { _outgoing.TryRemove(instance); ConnectionFailureInfo failureInfo; if (_outgoingFailureInfo.TryGetValue(instance.Destination, out failureInfo) == false) { return; } _reconnectQueue.Add(failureInfo); if (_log.IsInfoEnabled) { _log.Info($"Document replication connection ({instance.Destination}) failed, and the connection will be retried later.", e); } } }
private void OutgoingHandlerAdded(OutgoingReplicationHandler handler) { handler.HandleReplicationPulse += HandleReplicationPulse; }
private void OutgoingHandlerRemoved(OutgoingReplicationHandler handler) { handler.HandleReplicationPulse -= HandleReplicationPulse; }
public ReplicationDocumentSender(Stream stream, OutgoingReplicationHandler parent, Logger log) { _log = log; _stream = stream; _parent = parent; }