package store import ( "context" "database/sql" "errors" "time" "github.com/google/uuid" ) type FeedAction struct { Domain string `json:"-"` Owner string `json:"-"` RequestID string `json:"request_id"` Source string `json:"source"` ID string `json:"id"` Field string `json:"field"` Desired bool `json:"desired"` SourceVersion int64 `json:"source_version"` Status string `json:"status"` Claim string `json:"-"` UntilMS int64 `json:"-"` CreatedMS int64 `json:"created_ms"` Error string `json:"error"` } const feedActionColumns = `domain_uuid,owner_uuid,request_id,source_uuid,item_id,field,desired,source_version,status,claim,until_ms,created_ms,error` func scanFeedAction(row interface{ Scan(...any) error }) (a FeedAction, e error) { e = row.Scan(&a.Domain, &a.Owner, &a.RequestID, &a.Source, &a.ID, &a.Field, &a.Desired, &a.SourceVersion, &a.Status, &a.Claim, &a.UntilMS, &a.CreatedMS, &a.Error) return } func (s *Store) FeedAction(ctx context.Context, domain, owner, source, id string) (result *FeedAction, resultErr error) { defer func() { resultErr = s.sqlError("feeds repository", resultErr) }() ctx, cancel := context.WithTimeout(ctx, 3*time.Second) defer cancel() if e := s.feedActor(ctx, s.DB, domain, owner, false); e != nil { return nil, e } a, e := scanFeedAction(s.DB.QueryRowContext(ctx, `SELECT `+feedActionColumns+` FROM feed_actions WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND source_uuid=`+s.sqlParam(3)+` AND item_id=`+s.sqlParam(4)+` ORDER BY created_ms DESC,request_id DESC LIMIT 1`, domain, owner, source, id)) if errors.Is(e, sql.ErrNoRows) { return nil, nil } return &a, e } func (s *Store) QueueFeedAction(ctx context.Context, domain, owner string, a FeedAction) (FeedAction, error) { if _, e := uuid.Parse(a.RequestID); e != nil { return a, ErrTaskInvalid } if (a.Field != "read" && a.Field != "starred") || a.ID == "" || len(a.ID) > 1024 { return a, ErrTaskInvalid } a.Domain, a.Owner = domain, owner a.Error, a.Claim, a.UntilMS = "", "", 0 e := s.feedWrite(ctx, domain, owner, func(tx *sql.Tx) error { old, e := scanFeedAction(tx.QueryRowContext(ctx, `SELECT `+feedActionColumns+` FROM feed_actions WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND request_id=`+s.sqlParam(3), domain, owner, a.RequestID)) if e == nil { if old.Source != a.Source || old.ID != a.ID || old.Field != a.Field || old.Desired != a.Desired || old.SourceVersion != a.SourceVersion { return ErrTaskConflict } a = old return nil } if !errors.Is(e, sql.ErrNoRows) { return e } var allowed bool if e = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM feed_sources s JOIN feed_items i ON i.source_uuid=s.uuid WHERE s.domain_uuid=`+s.sqlParam(1)+` AND s.owner_uuid=`+s.sqlParam(2)+` AND s.uuid=`+s.sqlParam(3)+` AND i.id=`+s.sqlParam(4)+` AND s.provider='freshrss' AND s.enabled=1 AND s.write_enabled=1 AND s.version=`+s.sqlParam(5)+`)`, domain, owner, a.Source, a.ID, a.SourceVersion).Scan(&allowed); e != nil { return e } if !allowed { return ErrTaskConflict } var total, pending int var lastCreated int64 if e = tx.QueryRowContext(ctx, `SELECT count(*),COALESCE(sum(CASE WHEN status IN ('queued','preparing','sending','unknown','check_queued','checking') THEN 1 ELSE 0 END),0),COALESCE(MAX(created_ms),0) FROM feed_actions WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2), domain, owner).Scan(&total, &pending, &lastCreated); e != nil { return e } if total >= 10000 || pending >= 20 { return ErrTaskDAVLimit } if e = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM feed_actions WHERE source_uuid=`+s.sqlParam(1)+` AND item_id=`+s.sqlParam(2)+` AND status IN ('queued','preparing','sending','unknown','check_queued','checking'))`, a.Source, a.ID).Scan(&allowed); e != nil { return e } if allowed { return ErrTaskConflict } a.Status, a.CreatedMS = "queued", time.Now().UnixMilli() // Keep "latest" meaningful without SQLite rowid, including same-ms // requests and a backward wall clock. The writer lock serializes owners. if a.CreatedMS <= lastCreated { a.CreatedMS = lastCreated + 1 if a.CreatedMS <= lastCreated { return ErrTaskInvalid } } _, e = tx.ExecContext(ctx, `INSERT INTO feed_actions(domain_uuid,owner_uuid,request_id,source_uuid,item_id,field,desired,source_version,status,created_ms) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`,`+s.sqlParam(8)+`,`+s.sqlParam(9)+`,`+s.sqlParam(10)+`)`, domain, owner, a.RequestID, a.Source, a.ID, a.Field, boolToInt(a.Desired), a.SourceVersion, a.Status, a.CreatedMS) return e }) return a, e } // Recheck is deliberately read-only at the remote side, even with writeback OFF. func (s *Store) RecheckFeedAction(ctx context.Context, domain, owner, request string) error { return s.feedWrite(ctx, domain, owner, func(tx *sql.Tx) error { r, e := tx.ExecContext(ctx, `UPDATE feed_actions SET status='check_queued',error='' WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND request_id=`+s.sqlParam(3)+` AND status='unknown' AND until_ms<`+s.sqlParam(4)+` AND EXISTS(SELECT 1 FROM feed_sources s WHERE s.uuid=feed_actions.source_uuid AND s.domain_uuid=feed_actions.domain_uuid AND s.owner_uuid=feed_actions.owner_uuid AND s.provider='freshrss' AND s.enabled=1)`, domain, owner, request, time.Now().UnixMilli()) return feedActionAffected(r, e) }) } func feedActionAffected(r sql.Result, e error) error { if e != nil { return e } n, e := r.RowsAffected() if e != nil { return e } if n != 1 { return ErrTaskConflict } return nil } func (s *Store) DueFeedActions(ctx context.Context) (result []FeedAction, resultErr error) { defer func() { resultErr = s.sqlError("feeds repository", resultErr) }() if s.ReadOnly { return nil, ErrReadOnly } ctx, cancel := context.WithTimeout(ctx, 3*time.Second) defer cancel() tx, e := s.DB.BeginTx(ctx, nil) if e != nil { return nil, e } defer tx.Rollback() if e = s.lockTaskWriter(ctx, tx); e != nil { return nil, e } now := time.Now().UnixMilli() // Recovery changes only our receipts, never retries an uncertain remote write. if _, e := tx.ExecContext(ctx, `UPDATE feed_actions SET status=CASE WHEN status IN ('sending','checking') THEN 'unknown' ELSE 'failed' END,error='expired' WHERE (domain_uuid,owner_uuid,request_id) IN (SELECT domain_uuid,owner_uuid,request_id FROM feed_actions WHERE (status IN ('preparing','sending','checking') AND until_ms<`+s.sqlParam(1)+`) OR (status='queued' AND created_ms<`+s.sqlParam(2)+`) ORDER BY created_ms,request_id LIMIT 100)`, now, now-300000); e != nil { return nil, e } rows, e := tx.QueryContext(ctx, `SELECT `+feedActionColumns+` FROM feed_actions WHERE status IN ('queued','check_queued') AND EXISTS(SELECT 1 FROM feed_sources s JOIN principals p ON p.uuid=s.owner_uuid JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=s.domain_uuid JOIN domains d ON d.uuid=s.domain_uuid WHERE s.uuid=feed_actions.source_uuid AND s.enabled=1 AND s.lease_until<`+s.sqlParam(1)+` AND p.state='active' AND m.state='active' AND d.enabled=1 AND COALESCE(d.placement,'local')='local'`+s.feedCampusSQL()+` AND NOT EXISTS(SELECT 1 FROM config c WHERE c.domain_uuid=s.domain_uuid AND c.key='system_extension_states' AND `+s.feedDisabledConfigSQL()+`)) ORDER BY created_ms LIMIT 2`, now) if e != nil { return nil, e } defer rows.Close() out := []FeedAction{} for rows.Next() { a, e := scanFeedAction(rows) if e != nil { return nil, e } out = append(out, a) } if e = rows.Err(); e != nil { return nil, e } if e = rows.Close(); e != nil { return nil, e } return out, tx.Commit() } func (s *Store) ClaimFeedAction(ctx context.Context, a FeedAction) (FeedAction, FeedSource, error) { var source FeedSource e := s.feedWrite(ctx, a.Domain, a.Owner, func(tx *sql.Tx) error { var e error source, e = scanFeedSource(tx.QueryRowContext(ctx, `SELECT `+feedSourceColumns+` FROM feed_sources WHERE uuid=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` AND owner_uuid=`+s.sqlParam(3), a.Source, a.Domain, a.Owner)) if e != nil { return e } check := a.Status == "check_queued" if !source.Enabled || source.Provider != "freshrss" || (!check && (!source.WriteEnabled || source.Version != a.SourceVersion)) { return ErrTaskConflict } now := time.Now().UnixMilli() a.Claim = uuid.NewString() a.UntilMS = now + 60000 state := "preparing" if check { state = "checking" } r, e := tx.ExecContext(ctx, `UPDATE feed_sources SET lease=`+s.sqlParam(1)+`,lease_until=`+s.sqlParam(2)+` WHERE uuid=`+s.sqlParam(3)+` AND lease_until<`+s.sqlParam(4), a.Claim, a.UntilMS, a.Source, now) if e = feedActionAffected(r, e); e != nil { return e } r, e = tx.ExecContext(ctx, `UPDATE feed_actions SET status=`+s.sqlParam(1)+`,claim=`+s.sqlParam(2)+`,until_ms=`+s.sqlParam(3)+` WHERE domain_uuid=`+s.sqlParam(4)+` AND owner_uuid=`+s.sqlParam(5)+` AND request_id=`+s.sqlParam(6)+` AND status=`+s.sqlParam(7)+` AND (status='check_queued' OR created_ms>`+s.sqlParam(8)+`)`, state, a.Claim, a.UntilMS, a.Domain, a.Owner, a.RequestID, a.Status, now-300000) if e = feedActionAffected(r, e); e != nil { return e } a.Status = state source.Lease = a.Claim source.LeaseUntil = a.UntilMS return nil }) return a, source, e } func (s *Store) MarkFeedActionSending(ctx context.Context, a FeedAction, source FeedSource) error { return s.feedWrite(ctx, a.Domain, a.Owner, func(tx *sql.Tx) error { r, e := tx.ExecContext(ctx, `UPDATE feed_actions SET status='sending' WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND request_id=`+s.sqlParam(3)+` AND claim=`+s.sqlParam(4)+` AND status='preparing' AND until_ms>`+s.sqlParam(5)+` AND EXISTS(SELECT 1 FROM feed_sources WHERE uuid=`+s.sqlParam(6)+` AND enabled=1 AND write_enabled=1 AND version=`+s.sqlParam(7)+` AND lease=`+s.sqlParam(8)+`)`, a.Domain, a.Owner, a.RequestID, a.Claim, time.Now().UnixMilli(), a.Source, source.Version, a.Claim) return feedActionAffected(r, e) }) } func (s *Store) CompleteFeedAction(ctx context.Context, a FeedAction, source FeedSource, status, code string, observed *FeedItem) error { if (observed != nil && observed.ID != a.ID) || ((status == "confirmed" || status == "conflict") && observed == nil) { return ErrTaskInvalid } if status != "confirmed" && status != "unknown" && status != "failed" && status != "conflict" { return ErrTaskInvalid } switch code { case "", "network", "credentials", "invalid_feed", "remote_error", "conflict", "limit": default: return ErrTaskInvalid } return s.feedWrite(ctx, a.Domain, a.Owner, func(tx *sql.Tx) error { r, e := tx.ExecContext(ctx, `UPDATE feed_sources SET lease='',lease_until=0 WHERE uuid=`+s.sqlParam(1)+` AND version=`+s.sqlParam(2)+` AND lease=`+s.sqlParam(3)+` AND lease_until>`+s.sqlParam(4)+` AND enabled=1`, a.Source, source.Version, a.Claim, time.Now().UnixMilli()) if e = feedActionAffected(r, e); e != nil { return e } r, e = tx.ExecContext(ctx, `UPDATE feed_actions SET status=`+s.sqlParam(1)+`,error=`+s.sqlParam(2)+`,until_ms=CASE WHEN `+s.sqlParam(3)+`='unknown' THEN until_ms ELSE 0 END WHERE domain_uuid=`+s.sqlParam(4)+` AND owner_uuid=`+s.sqlParam(5)+` AND request_id=`+s.sqlParam(6)+` AND claim=`+s.sqlParam(7)+` AND status IN ('preparing','sending','checking')`, status, code, status, a.Domain, a.Owner, a.RequestID, a.Claim) if e = feedActionAffected(r, e); e != nil { return e } if observed != nil { _, e = tx.ExecContext(ctx, `UPDATE feed_items SET is_read=`+s.sqlParam(1)+`,starred=`+s.sqlParam(2)+` WHERE source_uuid=`+s.sqlParam(3)+` AND id=`+s.sqlParam(4), boolToInt(observed.Read), boolToInt(observed.Starred), a.Source, a.ID) } return e }) }