Method mainLoop

pkg/devspace/sync/downstream.go:158–209

()

}

func (d *downstream) mainLoop() error {
	lastAmountChanges := int64(0)
	recheckInterval := 1700
	if !d.sync.Options.Polling {
		recheckInterval = 500
	}

	var (
		changeTimer time.Time
	)
	for {
		select {
		case <-d.sync.ctx.Done():
			return nil
		case <-time.After(time.Duration(recheckInterval) * time.Millisecond):
			break
		}

		// Check for changes remotely
		ctx, cancel := context.WithTimeout(d.sync.ctx, time.Minute*10)
		changeAmount, err := d.client.ChangesCount(ctx, &remote.Empty{})
		cancel()
		if err != nil {
			return errors.Wrap(err, "count changes")
		}

		// start waiting timer
		if changeAmount.Amount > 0 && lastAmountChanges == 0 {
			changeTimer = time.Now().Add(waitForMoreChangesTimeout)
		}

		// Compare change amount
		if lastAmountChanges > 0 && (time.Now().After(changeTimer) || changeAmount.Amount > 25000 || changeAmount.Amount == lastAmountChanges) {
			d.sync.fileIndex.fileMapMutex.Lock()
			changes, err := d.collectChanges(false)
			d.sync.fileIndex.fileMapMutex.Unlock()
			if err != nil {
				return errors.Wrap(err, "collect changes")
			}

			err = d.applyChanges(changes, false)
			if err != nil {
				return errors.Wrap(err, "apply changes")
			}

			lastAmountChanges = 0
			changeTimer = time.Time{}
		} else {
			lastAmountChanges = changeAmount.Amount
		}
	}
}

func (d *downstream) shouldKeep(change *remote.Change) bool {
	// Is a delete change?