GoToSocial/internal/timeline/get.go

// GoToSocial
// Copyright (C) GoToSocial Authors admin@gotosocial.org
// SPDX-License-Identifier: AGPL-3.0-or-later
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package timeline

import (
	"container/list"
	"context"
	"errors"
	"time"

	"codeberg.org/gruf/go-kv"
	"github.com/superseriousbusiness/gotosocial/internal/db"
	"github.com/superseriousbusiness/gotosocial/internal/gtserror"
	"github.com/superseriousbusiness/gotosocial/internal/id"
	"github.com/superseriousbusiness/gotosocial/internal/log"
)

func (t *timeline) LastGot() time.Time {
	t.Lock()
	defer t.Unlock()
	return t.lastGot
}

func (t *timeline) Get(ctx context.Context, amount int, maxID string, sinceID string, minID string, prepareNext bool) ([]Preparable, error) {
	l := log.WithContext(ctx).
		WithFields(kv.Fields{
			{"accountID", t.timelineID},
			{"amount", amount},
			{"maxID", maxID},
			{"sinceID", sinceID},
			{"minID", minID},
		}...)
	l.Trace("entering get and updating t.lastGot")

	// Regardless of what happens below, update the
	// last time Get was called for this timeline.
	t.Lock()
	t.lastGot = time.Now()
	t.Unlock()

	var (
		items []Preparable
		err   error
	)

	switch {
	case maxID == "" && sinceID == "" && minID == "":
		// No params are defined so just fetch from the top.
		// This is equivalent to a user starting to view
		// their timeline from newest -> older posts.
		items, err = t.getXBetweenIDs(ctx, amount, id.Highest, id.Lowest, true)

		// Cache expected next query to speed up scrolling.
		// Assume the user will be scrolling downwards from
		// the final ID in items.
		if prepareNext && err == nil && len(items) != 0 {
			nextMaxID := items[len(items)-1].GetID()
			t.prepareNextQuery(amount, nextMaxID, "", "")
		}

	case maxID != "" && sinceID == "" && minID == "":
		// Only maxID is defined, so fetch from maxID onwards.
		// This is equivalent to a user paging further down
		// their timeline from newer -> older posts.
		items, err = t.getXBetweenIDs(ctx, amount, maxID, id.Lowest, true)

		// Cache expected next query to speed up scrolling.
		// Assume the user will be scrolling downwards from
		// the final ID in items.
		if prepareNext && err == nil && len(items) != 0 {
			nextMaxID := items[len(items)-1].GetID()
			t.prepareNextQuery(amount, nextMaxID, "", "")
		}

	// In the next cases, maxID is defined, and so are
	// either sinceID or minID. This is equivalent to
	// a user opening an in-progress timeline and asking
	// for a slice of posts somewhere in the middle, or
	// trying to "fill in the blanks" between two points,
	// paging either up or down.
	case maxID != "" && sinceID != "":
		items, err = t.getXBetweenIDs(ctx, amount, maxID, sinceID, true)

		// Cache expected next query to speed up scrolling.
		// We can assume the caller is scrolling downwards.
		// Guess id.Lowest as sinceID, since we don't actually
		// know what the next sinceID would be.
		if prepareNext && err == nil && len(items) != 0 {
			nextMaxID := items[len(items)-1].GetID()
			t.prepareNextQuery(amount, nextMaxID, id.Lowest, "")
		}

	case maxID != "" && minID != "":
		items, err = t.getXBetweenIDs(ctx, amount, maxID, minID, false)

		// Cache expected next query to speed up scrolling.
		// We can assume the caller is scrolling upwards.
		// Guess id.Highest as maxID, since we don't actually
		// know what the next maxID would be.
		if prepareNext && err == nil && len(items) != 0 {
			prevMinID := items[0].GetID()
			t.prepareNextQuery(amount, id.Highest, "", prevMinID)
		}

	// In the final cases, maxID is not defined, but
	// either sinceID or minID are. This is equivalent to
	// a user either "pulling up" at the top of their timeline
	// to refresh it and check if newer posts have come in, or
	// trying to scroll upwards from an old post to see what
	// they missed since then.
	//
	// In these calls, we use the highest possible ulid as
	// behindID because we don't have a cap for newest that
	// we're interested in.
	case maxID == "" && sinceID != "":
		items, err = t.getXBetweenIDs(ctx, amount, id.Highest, sinceID, true)

		// We can't cache an expected next query for this one,
		// since presumably the caller is at the top of their
		// timeline already.

	case maxID == "" && minID != "":
		items, err = t.getXBetweenIDs(ctx, amount, id.Highest, minID, false)

		// Cache expected next query to speed up scrolling.
		// We can assume the caller is scrolling upwards.
		// Guess id.Highest as maxID, since we don't actually
		// know what the next maxID would be.
		if prepareNext && err == nil && len(items) != 0 {
			prevMinID := items[0].GetID()
			t.prepareNextQuery(amount, id.Highest, "", prevMinID)
		}

	default:
		err = gtserror.New("switch statement exhausted with no results")
	}

	return items, err
}

// getXBetweenIDs returns x amount of items somewhere between (not including) the given IDs.
//
// If frontToBack is true, items will be served paging down from behindID.
// This corresponds to an api call to /timelines/home?max_id=WHATEVER&since_id=WHATEVER
//
// If frontToBack is false, items will be served paging up from beforeID.
// This corresponds to an api call to /timelines/home?max_id=WHATEVER&min_id=WHATEVER
func (t *timeline) getXBetweenIDs(ctx context.Context, amount int, behindID string, beforeID string, frontToBack bool) ([]Preparable, error) {
	l := log.
		WithContext(ctx).
		WithFields(kv.Fields{
			{"amount", amount},
			{"behindID", behindID},
			{"beforeID", beforeID},
			{"frontToBack", frontToBack},
		}...)
	l.Trace("entering getXBetweenID")

	// Assume length we need to return.
	items := make([]Preparable, 0, amount)

	if beforeID >= behindID {
		// This is an impossible situation, we
		// can't serve anything between these.
		return items, nil
	}

	// Try to ensure we have enough items prepared.
	if err := t.prepareXBetweenIDs(ctx, amount, behindID, beforeID, frontToBack); err != nil {
		// An error here doesn't necessarily mean we
		// can't serve anything, so log + keep going.
		l.Debugf("error calling prepareXBetweenIDs: %s", err)
	}

	var (
		beforeIDMark *list.Element
		served       int
		// Our behavior while ranging through the
		// list changes depending on if we're
		// going front-to-back or back-to-front.
		//
		// To avoid checking which one we're doing
		// in each loop iteration, define our range
		// function here outside the loop.
		//
		// The bool indicates to the caller whether
		// iteration should continue (true) or stop
		// (false).
		rangeF func(e *list.Element) (bool, error)
		// If we get certain errors on entries as we're
		// looking through, we might want to cheekily
		// remove their elements from the timeline.
		// Everything added to this slice will be removed.
		removeElements = []*list.Element{}
	)

	defer func() {
		for _, e := range removeElements {
			t.items.data.Remove(e)
		}
	}()

	if frontToBack {
		// We're going front-to-back, which means we
		// don't need to look for a mark per se, we
		// just keep serving items until we've reached
		// a point where the items are out of the range
		// we're interested in.
		rangeF = func(e *list.Element) (bool, error) {
			entry := e.Value.(*indexedItemsEntry) //nolint:forcetypeassert

			if entry.itemID >= behindID {
				// ID of this item is too high,
				// just keep iterating.
				l.Trace("item is too new, continuing")
				return true, nil
			}

			if entry.itemID <= beforeID {
				// We've gone as far as we can through
				// the list and reached entries that are
				// now too old for us, stop here.
				l.Trace("reached older items, breaking")
				return false, nil
			}

			l.Trace("entry is just right")

			if entry.prepared == nil {
				// Whoops, this entry isn't prepared yet; some
				// race condition? That's OK, we can do it now.
				prepared, err := t.prepareFunction(ctx, t.timelineID, entry.itemID)
				if err != nil {
					if errors.Is(err, db.ErrNoEntries) {
						// ErrNoEntries means something has been deleted,
						// so we'll likely not be able to ever prepare this.
						// This means we can remove it and skip past it.
						l.Debugf("db.ErrNoEntries while trying to prepare %s; will remove from timeline", entry.itemID)
						removeElements = append(removeElements, e)
						return true, nil
					}
					// We've got a proper db error.
					err = gtserror.Newf("db error while trying to prepare %s: %w", entry.itemID, err)
					return false, err
				}
				entry.prepared = prepared
			}

			items = append(items, entry.prepared)

			served++
			return served < amount, nil
		}
	} else {
		// Iterate through the list from the top, until
		// we reach an item with id smaller than beforeID;
		// ie., an item OLDER than beforeID. At that point,
		// we can stop looking because we're not interested
		// in older entries.
		rangeF = func(e *list.Element) (bool, error) {
			// Move the mark back one place each loop.
			beforeIDMark = e

			//nolint:forcetypeassert
			if entry := e.Value.(*indexedItemsEntry); entry.itemID <= beforeID {
				// We've gone as far as we can through
				// the list and reached entries that are
				// now too old for us, stop here.
				l.Trace("reached older items, breaking")
				return false, nil
			}

			return true, nil
		}
	}

	// Iterate through the list until the function
	// we defined above instructs us to stop.
	for e := t.items.data.Front(); e != nil; e = e.Next() {
		keepGoing, err := rangeF(e)
		if err != nil {
			return nil, err
		}

		if !keepGoing {
			break
		}
	}

	if frontToBack || beforeIDMark == nil {
		// If we're serving front to back, then
		// items should be populated by now. If
		// we're serving back to front but didn't
		// find any items newer than beforeID,
		// we can just return empty items.
		return items, nil
	}

	// We're serving back to front, so iterate upwards
	// towards the front of the list from the mark we found,
	// until we either get to the front, serve enough
	// items, or reach behindID.
	//
	// To preserve ordering, we need to reverse the slice
	// when we're finished.
	for e := beforeIDMark; e != nil; e = e.Prev() {
		entry := e.Value.(*indexedItemsEntry) //nolint:forcetypeassert

		if entry.itemID == beforeID {
			// Don't include the beforeID
			// entry itself, just continue.
			l.Trace("entry item ID is equal to beforeID, skipping")
			continue
		}

		if entry.itemID >= behindID {
			// We've reached items that are
			// newer than what we're looking
			// for, just stop here.
			l.Trace("reached newer items, breaking")
			break
		}

		if entry.prepared == nil {
			// Whoops, this entry isn't prepared yet; some
			// race condition? That's OK, we can do it now.
			prepared, err := t.prepareFunction(ctx, t.timelineID, entry.itemID)
			if err != nil {
				if errors.Is(err, db.ErrNoEntries) {
					// ErrNoEntries means something has been deleted,
					// so we'll likely not be able to ever prepare this.
					// This means we can remove it and skip past it.
					l.Debugf("db.ErrNoEntries while trying to prepare %s; will remove from timeline", entry.itemID)
					removeElements = append(removeElements, e)
					continue
				}
				// We've got a proper db error.
				err = gtserror.Newf("db error while trying to prepare %s: %w", entry.itemID, err)
				return nil, err
			}
			entry.prepared = prepared
		}

		items = append(items, entry.prepared)

		served++
		if served >= amount {
			break
		}
	}

	// Reverse order of items.
	// https://zchee.github.io/golang-wiki/SliceTricks/#reversing
	for l, r := 0, len(items)-1; l < r; l, r = l+1, r-1 {
		items[l], items[r] = items[r], items[l]
	}

	return items, nil
}

func (t *timeline) prepareNextQuery(amount int, maxID string, sinceID string, minID string) {
	var (
		// We explicitly use context.Background() rather than
		// accepting a context param because we don't want this
		// to stop/break when the calling context finishes.
		ctx = context.Background()
		err error
	)

	// Always perform this async so caller doesn't have to wait.
	go func() {
		switch {
		case maxID == "" && sinceID == "" && minID == "":
			err = t.prepareXBetweenIDs(ctx, amount, id.Highest, id.Lowest, true)
		case maxID != "" && sinceID == "" && minID == "":
			err = t.prepareXBetweenIDs(ctx, amount, maxID, id.Lowest, true)
		case maxID != "" && sinceID != "":
			err = t.prepareXBetweenIDs(ctx, amount, maxID, sinceID, true)
		case maxID != "" && minID != "":
			err = t.prepareXBetweenIDs(ctx, amount, maxID, minID, false)
		case maxID == "" && sinceID != "":
			err = t.prepareXBetweenIDs(ctx, amount, id.Highest, sinceID, true)
		case maxID == "" && minID != "":
			err = t.prepareXBetweenIDs(ctx, amount, id.Highest, minID, false)
		default:
			err = gtserror.New("switch statement exhausted with no results")
		}

		if err != nil {
			log.
				WithContext(ctx).
				WithFields(kv.Fields{
					{"amount", amount},
					{"maxID", maxID},
					{"sinceID", sinceID},
					{"minID", minID},
				}...).
				Warnf("error preparing next query: %s", err)
		}
	}()
}