add --init-period and --init-max-failures flags

main.go

@@ -186,6 +186,12 @@ func main() {
 	flPeriod := pflag.Duration("period",
 		envDuration(10*time.Second, "GITSYNC_PERIOD", "GIT_SYNC_PERIOD"),
 		"how long to wait between syncs, must be >= 10ms; --wait overrides this")
+	flInitPeriod := pflag.Duration("init-period",
+		envDuration(0, "GITSYNC_INIT_PERIOD"),
+		"how long to wait between sync attempts until the first success, must be >= 10ms if set; if unset, --period is used")
+	flInitTimeout := pflag.Duration("init-timeout",
+		envDuration(0, "GITSYNC_INIT_TIMEOUT"),
+		"the max time allowed for the initial sync to succeed; if unset, there is no timeout (retries forever until --max-failures)")
 	flSyncTimeout := pflag.Duration("sync-timeout",
 		envDuration(120*time.Second, "GITSYNC_SYNC_TIMEOUT", "GIT_SYNC_SYNC_TIMEOUT"),
 		"the total time allowed for one complete sync, must be >= 10ms; --timeout overrides this")
@@ -469,6 +475,12 @@ func main() {
 	if *flPeriod < 10*time.Millisecond {
 		fatalConfigErrorf(log, true, "invalid flag: --period must be at least 10ms")
 	}
+	if *flInitPeriod != 0 && *flInitPeriod < 10*time.Millisecond {
+		fatalConfigErrorf(log, true, "invalid flag: --init-period must be at least 10ms")
+	}
+	if *flInitTimeout != 0 && *flInitTimeout < 10*time.Millisecond {
+		fatalConfigErrorf(log, true, "invalid flag: --init-timeout must be at least 10ms")
+	}
 
 	if *flDeprecatedChmod != 0 {
 		fatalConfigErrorf(log, true, "deprecated flag: --change-permissions is no longer supported")
@@ -912,20 +924,35 @@ func main() {
 
 	failCount := 0
 	syncCount := uint64(0)
+	initialSyncDone := false
+	var initStart time.Time
+	if *flInitPeriod != 0 || *flInitTimeout != 0 {
+		initStart = time.Now()
+	}
 	for {
 		start := time.Now()
 		ctx, cancel := context.WithTimeout(context.Background(), *flSyncTimeout)
 
 		if changed, hash, err := git.SyncRepo(ctx, refreshCreds); err != nil {
 			failCount++
 			updateSyncMetrics(metricKeyError, start)
+			if isInitTimedOut(*flInitTimeout, initialSyncDone, initStart) {
+				log.Error(err, "initial sync timed out", "initTimeout", flInitTimeout.String(), "failCount", failCount)
+				os.Exit(1)
+			}
 			if *flMaxFailures >= 0 && failCount >= *flMaxFailures {
 				// Exit after too many retries, maybe the error is not recoverable.
 				log.Error(err, "too many failures, aborting", "failCount", failCount)
 				os.Exit(1)
 			}
 			log.Error(err, "error syncing repo, will retry", "failCount", failCount)
 		} else {
+			if !initialSyncDone {
+				initialSyncDone = true
+				if *flInitPeriod != 0 {
+					log.V(0).Info("initial sync complete, switching to normal period", "initPeriod", flInitPeriod.String(), "period", flPeriod.String())
+				}
+			}
 			// this might have been called before, but also might not have
 			setRepoReady()
 			// We treat the first loop as a sync, including sending hooks.
@@ -989,12 +1016,14 @@ func main() {
 			log.DeleteErrorFile()
 		}
 
-		log.V(3).Info("next sync", "waitTime", flPeriod.String(), "syncCount", syncCount)
+		// Use init-period for retries before the first successful sync.
+		waitTime := chooseWaitTime(*flPeriod, *flInitPeriod, initialSyncDone)
+		log.V(3).Info("next sync", "waitTime", waitTime.String(), "syncCount", syncCount)
 		cancel()
 
 		// Sleep until the next sync. If syncSig is set then the sleep may
 		// be interrupted by that signal.
-		t := time.NewTimer(*flPeriod)
+		t := time.NewTimer(waitTime)
 		select {
 		case <-t.C:
 		case <-sigChan:
@@ -1144,6 +1173,24 @@ func setRepoReady() {
 	repoReady = true
 }
 
+// chooseWaitTime returns the appropriate wait duration based on whether the
+// initial sync has completed. If initPeriod is non-zero and the initial sync
+// is not yet done, it returns initPeriod. Otherwise it returns period.
+func chooseWaitTime(period, initPeriod time.Duration, initialSyncDone bool) time.Duration {
+	if !initialSyncDone && initPeriod != 0 {
+		return initPeriod
+	}
+	return period
+}
+
+// isInitTimedOut returns true if the initial sync has exceeded the init-timeout.
+func isInitTimedOut(initTimeout time.Duration, initialSyncDone bool, initStart time.Time) bool {
+	if initTimeout == 0 || initialSyncDone {
+		return false
+	}
+	return time.Since(initStart) >= initTimeout
+}
+
 // Do no work, but don't do something that triggers go's runtime into thinking
 // it is deadlocked.
 func sleepForever() {
@@ -2589,6 +2636,18 @@ OPTIONS
             dynamic credentials from an external secrets system).
             See also $GITSYNC_PASSWORD.
 
+    --init-period <duration>, $GITSYNC_INIT_PERIOD
+            How long to wait between sync attempts until the first successful
+            sync.  Once the initial sync succeeds, --period is used instead.
+            This must be at least 10ms if set.  If not specified, --period is
+            used for all sync attempts.
+
+    --init-timeout <duration>, $GITSYNC_INIT_TIMEOUT
+            The maximum amount of time to keep retrying the initial sync
+            before failing.  If not specified, git-sync retries forever (or
+            until --max-failures is reached).  This must be at least 10ms if
+            set.
+
     --period <duration>, $GITSYNC_PERIOD
             How long to wait between sync attempts.  This must be at least
             10ms.  This flag obsoletes --wait, but if --wait is specified, it

main_test.go

@@ -425,6 +425,96 @@ func TestTouch(t *testing.T) {
 	}
 }
 
+func TestChooseWaitTime(t *testing.T) {
+	period := 10 * time.Second
+	initPeriod := 500 * time.Millisecond
+
+	cases := []struct {
+		name            string
+		period          time.Duration
+		initPeriod      time.Duration
+		initialSyncDone bool
+		expected        time.Duration
+	}{{
+		name:            "no init-period, not done",
+		period:          period,
+		initPeriod:      0,
+		initialSyncDone: false,
+		expected:        period,
+	}, {
+		name:            "no init-period, done",
+		period:          period,
+		initPeriod:      0,
+		initialSyncDone: true,
+		expected:        period,
+	}, {
+		name:            "init-period set, not done",
+		period:          period,
+		initPeriod:      initPeriod,
+		initialSyncDone: false,
+		expected:        initPeriod,
+	}, {
+		name:            "init-period set, done",
+		period:          period,
+		initPeriod:      initPeriod,
+		initialSyncDone: true,
+		expected:        period,
+	}}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := chooseWaitTime(tc.period, tc.initPeriod, tc.initialSyncDone)
+			if got != tc.expected {
+				t.Errorf("expected %v, got %v", tc.expected, got)
+			}
+		})
+	}
+}
+
+func TestIsInitTimedOut(t *testing.T) {
+	cases := []struct {
+		name            string
+		initTimeout     time.Duration
+		initialSyncDone bool
+		elapsed         time.Duration
+		expected        bool
+	}{{
+		name:            "no timeout set",
+		initTimeout:     0,
+		initialSyncDone: false,
+		elapsed:         time.Hour,
+		expected:        false,
+	}, {
+		name:            "timeout set, already done",
+		initTimeout:     time.Second,
+		initialSyncDone: true,
+		elapsed:         time.Hour,
+		expected:        false,
+	}, {
+		name:            "timeout set, not done, not expired",
+		initTimeout:     10 * time.Second,
+		initialSyncDone: false,
+		elapsed:         time.Second,
+		expected:        false,
+	}, {
+		name:            "timeout set, not done, expired",
+		initTimeout:     time.Second,
+		initialSyncDone: false,
+		elapsed:         2 * time.Second,
+		expected:        true,
+	}}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			initStart := time.Now().Add(-tc.elapsed)
+			got := isInitTimedOut(tc.initTimeout, tc.initialSyncDone, initStart)
+			if got != tc.expected {
+				t.Errorf("expected %v, got %v", tc.expected, got)
+			}
+		})
+	}
+}
+
 func TestHasGitLockFile(t *testing.T) {
 	testCases := map[string]struct {
 		inputFilePath  []string