Method tick

coderd/x/gitsync/worker.go:180–275

(ctx context.Context)

}

func (w *Worker) tick(ctx context.Context) {
	// Use a dedicated tick timeout that is longer than the
	// polling interval. This gives concurrent HTTP calls enough
	// headroom without stalling the next tick excessively.
	ctx, cancel := context.WithTimeout(ctx, w.tickTimeout)
	defer cancel()

	acquiredRows, err := w.store.AcquireStaleChatDiffStatuses(ctx, w.batchSize)
	if err != nil {
		w.logger.Warn(ctx, "acquire stale chat diff statuses",
			slog.Error(err))
		return
	}
	if len(acquiredRows) == 0 {
		return
	}

	// Build refresh requests directly from acquired rows.
	requests := make([]RefreshRequest, 0, len(acquiredRows))
	for _, row := range acquiredRows {
		requests = append(requests, RefreshRequest{
			Row:     chatDiffStatusFromRow(row),
			OwnerID: row.OwnerID,
		})
	}

	results, err := w.refresher.Refresh(ctx, requests)
	if err != nil {
		w.logger.Warn(ctx, "batch refresh chat diff statuses",
			slog.Error(err))
		return
	}

	for _, res := range results {
		if res.Error != nil {
			w.logger.Debug(ctx, "refresh chat diff status",
				slog.F("chat_id", res.Request.Row.ChatID),
				slog.Error(res.Error))
			// Apply a longer backoff for rows whose owner has
			// no linked token — retrying every 2 minutes is
			// pointless until the user links their account.
			backoff := DiffStatusTTL
			if errors.Is(res.Error, ErrNoTokenAvailable) {
				backoff = NoTokenBackoff
			}
			// Back off so the row isn't retried immediately.
			if err := w.store.BackoffChatDiffStatus(ctx,
				database.BackoffChatDiffStatusParams{
					ChatID:  res.Request.Row.ChatID,
					StaleAt: w.clock.Now().UTC().Add(backoff),
				},
			); err != nil {
				w.logger.Warn(ctx, "backoff failed chat diff status",
					slog.F("chat_id", res.Request.Row.ChatID),
					slog.Error(err))
			}
			continue
		}