rss-tools @ 77475b6

···
        80
        80
         }

      
        81
        81
         

      
        82
        82
         func (mf *musicfeed) handleMusic(w http.ResponseWriter, r *http.Request) {

      
        83
        
        -	if !mf.refreshed.Load() {

      
        
        83
        +	if !mf.refreshed.Load() && (time.Now().Weekday() == time.Friday || mf.cacheMissing()) {

      
        84
        84
         		mf.refreshMu.Lock()

      
        85
        85
         		if !mf.refreshed.Load() {

      
        86
        86
         			mf.refresh(r.Context())

      ···
        106
        106
         func (mf *musicfeed) worker(ctx context.Context) error {

      
        107
        107
         	mf.logger.Info("starting musicfeed worker")

      
        108
        108
         

      
        109
        
        -	mf.maybeRefresh(ctx)

      
        110
        
        -

      
        111
        
        -	ticker := time.NewTicker(1 * time.Hour)

      
        112
        
        -	defer ticker.Stop()

      
        
        109
        +	// Only refresh on Fridays — releases drop on Friday, so we fetch once weekly

      
        
        110
        +	// to avoid rate-limiting MusicBrainz.

      
        
        111
        +	if time.Now().Weekday() == time.Friday {

      
        
        112
        +		mf.maybeRefresh(ctx)

      
        
        113
        +	}

      
        113
        114
         

      
        114
        115
         	for {

      
        
        116
        +		next := nextFridayRefresh(time.Now())

      
        
        117
        +		dur := time.Until(next)

      
        
        118
        +		mf.logger.Info("next music feed refresh", "at", next.Format("2006-01-02 15:04"), "in", dur.Round(time.Second))

      
        
        119
        +

      
        115
        120
         		select {

      
        116
        121
         		case <-ctx.Done():

      
        117
        122
         			return nil

      
        118
        
        -		case <-ticker.C:

      
        
        123
        +		case <-time.After(dur):

      
        119
        124
         			mf.maybeRefresh(ctx)

      
        120
        125
         		}

      
        121
        126
         	}

      
        122
        127
         }

      
        123
        128
         

      
        124
        
        -func (mf *musicfeed) maybeRefresh(ctx context.Context) {

      
        125
        
        -	now := time.Now()

      
        
        129
        +func nextFridayRefresh(after time.Time) time.Time {

      
        
        130
        +	const targetHour = 19

      
        
        131
        +	y, m, d := after.Date()

      
        
        132
        +	loc := after.Location()

      
        
        133
        +

      
        
        134
        +	// If today is Friday before target hour, return today at target hour.

      
        
        135
        +	if after.Weekday() == time.Friday {

      
        
        136
        +		target := time.Date(y, m, d, targetHour, 0, 0, 0, loc)

      
        
        137
        +		if after.Before(target) {

      
        
        138
        +			return target

      
        
        139
        +		}

      
        
        140
        +	}

      
        
        141
        +

      
        
        142
        +	// Otherwise advance to next Friday at target hour.

      
        
        143
        +	next := time.Date(y, m, d, 0, 0, 0, 0, loc).Add(24 * time.Hour)

      
        
        144
        +	for next.Weekday() != time.Friday {

      
        
        145
        +		next = next.Add(24 * time.Hour)

      
        
        146
        +	}

      
        
        147
        +	return time.Date(next.Year(), next.Month(), next.Day(), targetHour, 0, 0, 0, loc)

      
        
        148
        +}

      
        
        149
        +

      
        
        150
        +func (mf *musicfeed) cacheMissing() bool {

      
        
        151
        +	_, err := mf.bucket.Get([]byte("feed"))

      
        
        152
        +	return err != nil

      
        
        153
        +}

      
        126
        154
         

      
        
        155
        +func (mf *musicfeed) maybeRefresh(ctx context.Context) {

      
        127
        156
         	mf.refreshMu.Lock()

      
        128
        157
         	defer mf.refreshMu.Unlock()

      
        129
        158
         

      
        130
        
        -	if mf.refreshed.Load() && now.Weekday() != time.Friday {

      
        131
        
        -		return

      
        132
        
        -	}

      
        133
        
        -

      
        134
        159
         	if mf.refreshed.Load() {

      
        135
        160
         		raw, err := mf.bucket.Get([]byte("refreshed_at"))

      
        136
        161
         		if err == nil && raw != nil {

      
        137
        162
         			lastRefresh := time.Unix(int64(binary.BigEndian.Uint64(raw)), 0)

      
        138
        
        -			if isSameDay(lastRefresh, now) {

      
        
        163
        +			if isSameDay(lastRefresh, time.Now()) {

      
        139
        164
         				return

      
        140
        165
         			}

      
        141
        166
         		}