Method reconnect

db/active_replicator_common.go:244–339

reconnect asynchronously calls replicatorConnectFn until successful, or times out trying. Retry loop can be stopped by cancelling ctx

()

// reconnect asynchronously calls replicatorConnectFn until successful, or times out trying. Retry loop can be stopped by cancelling ctx
func (arc *activeReplicatorCommon) reconnect() {
	arc.reconnectActive.Set(true)
	go func() {
		base.DebugfCtx(arc.ctx, base.KeyReplicate, "starting reconnector")
		defer func() {
			arc.reconnectActive.Set(false)
		}()

		initialReconnectInterval := defaultInitialReconnectInterval
		if arc.config.InitialReconnectInterval != 0 {
			initialReconnectInterval = arc.config.InitialReconnectInterval
		}
		maxReconnectInterval := defaultMaxReconnectInterval
		if arc.config.MaxReconnectInterval != 0 {
			maxReconnectInterval = arc.config.MaxReconnectInterval
		}

		// ctx causes the retry loop to stop if cancelled
		ctx := arc.ctx

		// if a reconnect timeout is set, we'll wrap the existing so both can stop the retry loop
		var deadlineCancel context.CancelFunc
		if arc.config.TotalReconnectTimeout != 0 {
			ctx, deadlineCancel = context.WithDeadline(ctx, time.Now().Add(arc.config.TotalReconnectTimeout))
		}

		sleeperFunc := base.SleeperFuncCtx(
			base.CreateIndefiniteMaxDoublingSleeperFunc(
				int(initialReconnectInterval.Milliseconds()),
				int(maxReconnectInterval.Milliseconds())),
			ctx)

		retryFunc := func() (shouldRetry bool, err error, _ interface{}) {
			// check before and after acquiring lock to make sure to exit early if ActiveReplicatorCommon.Stop() was called.
			if ctx.Err() != nil {
				return false, ctx.Err(), nil
			}

			arc.lock.Lock()
			defer arc.lock.Unlock()

			if ctx.Err() != nil {
				return false, ctx.Err(), nil
			}

			base.DebugfCtx(arc.ctx, base.KeyReplicate, "Attempting to reconnect replicator %s", arc.config.ID)

			// preserve lastError from the previous connect attempt
			arc.setState(ReplicationStateReconnecting)

			// disconnect no-ops if nothing is active, but will close any checkpointer processes, blip contexts, etc, if active.
			base.TracefCtx(arc.ctx, base.KeyReplicate, "calling disconnect from reconnect")
			err = arc._disconnect()
			if err != nil {
				base.InfofCtx(arc.ctx, base.KeyReplicate, "error stopping replicator on reconnect: %v", err)
			}

			// set lastError, but don't set an error state inside the reconnect loop