i can't even
This commit is contained in:
tsmethurst
250
internal/timeline/get.go
Normal file
250
internal/timeline/get.go
Normal file
@ -0,0 +1,250 @@
|
||||
package timeline
|
||||
|
||||
import (
|
||||
"container/list"
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
apimodel "github.com/superseriousbusiness/gotosocial/internal/api/model"
|
||||
)
|
||||
|
||||
func (t *timeline) GetXFromTop(amount int) ([]*apimodel.Status, error) {
|
||||
// make a slice of statuses with the length we need to return
|
||||
statuses := make([]*apimodel.Status, 0, amount)
|
||||
|
||||
// if there are no prepared posts, just return the empty slice
|
||||
if t.preparedPosts.data == nil {
|
||||
t.preparedPosts.data = &list.List{}
|
||||
}
|
||||
|
||||
// make sure we have enough posts prepared to return
|
||||
if t.preparedPosts.data.Len() < amount {
|
||||
if err := t.PrepareFromTop(amount); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
// work through the prepared posts from the top and return
|
||||
var served int
|
||||
for e := t.preparedPosts.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*preparedPostsEntry)
|
||||
if !ok {
|
||||
return nil, errors.New("GetXFromTop: could not parse e as a preparedPostsEntry")
|
||||
}
|
||||
statuses = append(statuses, entry.prepared)
|
||||
served = served + 1
|
||||
if served >= amount {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
return statuses, nil
|
||||
}
|
||||
|
||||
func (t *timeline) GetXBehindID(amount int, behindID string) ([]*apimodel.Status, error) {
|
||||
// make a slice of statuses with the length we need to return
|
||||
statuses := make([]*apimodel.Status, 0, amount)
|
||||
|
||||
// if there are no prepared posts, just return the empty slice
|
||||
if t.preparedPosts.data == nil {
|
||||
t.preparedPosts.data = &list.List{}
|
||||
}
|
||||
|
||||
// iterate through the modified list until we hit the mark we're looking for
|
||||
var position int
|
||||
var behindIDMark *list.Element
|
||||
findMarkLoop:
|
||||
for e := t.preparedPosts.data.Front(); e != nil; e = e.Next() {
|
||||
position = position + 1
|
||||
entry, ok := e.Value.(*preparedPostsEntry)
|
||||
if !ok {
|
||||
return nil, errors.New("GetXBehindID: could not parse e as a preparedPostsEntry")
|
||||
}
|
||||
|
||||
if entry.statusID == behindID {
|
||||
fmt.Printf("\n\n\n GETXBEHINDID: FOUND BEHINDID %s WITH POSITION %d AND CREATEDAT %s \n\n\n", behindID, position, entry.createdAt.String())
|
||||
behindIDMark = e
|
||||
break findMarkLoop
|
||||
}
|
||||
}
|
||||
|
||||
// we didn't find it, so we need to make sure it's indexed and prepared and then try again
|
||||
if behindIDMark == nil {
|
||||
if err := t.IndexBehind(behindID, true, amount); err != nil {
|
||||
return nil, fmt.Errorf("GetXBehindID: error indexing behind and including ID %s", behindID)
|
||||
}
|
||||
if err := t.PrepareBehind(behindID, true, amount); err != nil {
|
||||
return nil, fmt.Errorf("GetXBehindID: error preparing behind and including ID %s", behindID)
|
||||
}
|
||||
return t.GetXBehindID(amount, behindID)
|
||||
}
|
||||
|
||||
// make sure we have enough posts prepared behind it to return what we're being asked for
|
||||
if t.preparedPosts.data.Len() < amount+position {
|
||||
fmt.Printf("\n\n\n GETXBEHINDID: PREPARED POSTS LENGTH %d WAS LESS THAN AMOUNT %d PLUS POSITION %d", t.preparedPosts.data.Len(), amount, position)
|
||||
if err := t.PrepareBehind(behindID, false, amount); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
fmt.Printf("\n\n\n GETXBEHINDID: PREPARED POSTS LENGTH IS NOW %d", t.preparedPosts.data.Len())
|
||||
}
|
||||
|
||||
// start serving from the entry right after the mark
|
||||
var served int
|
||||
serveloop:
|
||||
for e := behindIDMark.Next(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*preparedPostsEntry)
|
||||
if !ok {
|
||||
return nil, errors.New("GetXBehindID: could not parse e as a preparedPostsEntry")
|
||||
}
|
||||
|
||||
fmt.Printf("\n\n\n GETXBEHINDID: SERVING STATUS ID %s WITH CREATEDAT %s \n\n\n", entry.statusID, entry.createdAt.String())
|
||||
// serve up to the amount requested
|
||||
statuses = append(statuses, entry.prepared)
|
||||
served = served + 1
|
||||
if served >= amount {
|
||||
break serveloop
|
||||
}
|
||||
}
|
||||
|
||||
return statuses, nil
|
||||
}
|
||||
|
||||
func (t *timeline) GetXBeforeID(amount int, beforeID string, startFromTop bool) ([]*apimodel.Status, error) {
|
||||
// make a slice of statuses with the length we need to return
|
||||
statuses := make([]*apimodel.Status, 0, amount)
|
||||
|
||||
if t.preparedPosts.data == nil {
|
||||
t.preparedPosts.data = &list.List{}
|
||||
}
|
||||
|
||||
// iterate through the modified list until we hit the mark we're looking for
|
||||
var beforeIDMark *list.Element
|
||||
findMarkLoop:
|
||||
for e := t.preparedPosts.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*preparedPostsEntry)
|
||||
if !ok {
|
||||
return nil, errors.New("GetXBeforeID: could not parse e as a preparedPostsEntry")
|
||||
}
|
||||
|
||||
if entry.statusID == beforeID {
|
||||
beforeIDMark = e
|
||||
break findMarkLoop
|
||||
}
|
||||
}
|
||||
|
||||
// we didn't find it, so we need to make sure it's indexed and prepared and then try again
|
||||
if beforeIDMark == nil {
|
||||
if err := t.IndexBefore(beforeID, true, amount); err != nil {
|
||||
return nil, fmt.Errorf("GetXBeforeID: error indexing before and including ID %s", beforeID)
|
||||
}
|
||||
if err := t.PrepareBefore(beforeID, true, amount); err != nil {
|
||||
return nil, fmt.Errorf("GetXBeforeID: error preparing before and including ID %s", beforeID)
|
||||
}
|
||||
return t.GetXBeforeID(amount, beforeID, startFromTop)
|
||||
}
|
||||
|
||||
var served int
|
||||
|
||||
if startFromTop {
|
||||
// start serving from the front/top and keep going until we hit mark or get x amount statuses
|
||||
serveloopFromTop:
|
||||
for e := t.preparedPosts.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*preparedPostsEntry)
|
||||
if !ok {
|
||||
return nil, errors.New("GetXBeforeID: could not parse e as a preparedPostsEntry")
|
||||
}
|
||||
|
||||
if entry.statusID == beforeID {
|
||||
break serveloopFromTop
|
||||
}
|
||||
|
||||
// serve up to the amount requested
|
||||
statuses = append(statuses, entry.prepared)
|
||||
served = served + 1
|
||||
if served >= amount {
|
||||
break serveloopFromTop
|
||||
}
|
||||
}
|
||||
|
||||
} else if startFromTop {
|
||||
// start serving from the entry right before the mark
|
||||
serveloopFromBottom:
|
||||
for e := beforeIDMark.Prev(); e != nil; e = e.Prev() {
|
||||
entry, ok := e.Value.(*preparedPostsEntry)
|
||||
if !ok {
|
||||
return nil, errors.New("GetXBeforeID: could not parse e as a preparedPostsEntry")
|
||||
}
|
||||
|
||||
// serve up to the amount requested
|
||||
statuses = append(statuses, entry.prepared)
|
||||
served = served + 1
|
||||
if served >= amount {
|
||||
break serveloopFromBottom
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return statuses, nil
|
||||
}
|
||||
|
||||
func (t *timeline) GetXBetweenID(amount int, behindID string, beforeID string) ([]*apimodel.Status, error) {
|
||||
// make a slice of statuses with the length we need to return
|
||||
statuses := make([]*apimodel.Status, 0, amount)
|
||||
|
||||
// if there are no prepared posts, just return the empty slice
|
||||
if t.preparedPosts.data == nil {
|
||||
t.preparedPosts.data = &list.List{}
|
||||
}
|
||||
|
||||
// iterate through the modified list until we hit the mark we're looking for
|
||||
var position int
|
||||
var behindIDMark *list.Element
|
||||
findMarkLoop:
|
||||
for e := t.preparedPosts.data.Front(); e != nil; e = e.Next() {
|
||||
position = position + 1
|
||||
entry, ok := e.Value.(*preparedPostsEntry)
|
||||
if !ok {
|
||||
return nil, errors.New("GetXBetweenID: could not parse e as a preparedPostsEntry")
|
||||
}
|
||||
|
||||
if entry.statusID == behindID {
|
||||
behindIDMark = e
|
||||
break findMarkLoop
|
||||
}
|
||||
}
|
||||
|
||||
// we didn't find it
|
||||
if behindIDMark == nil {
|
||||
return nil, fmt.Errorf("GetXBetweenID: couldn't find status with ID %s", behindID)
|
||||
}
|
||||
|
||||
// make sure we have enough posts prepared behind it to return what we're being asked for
|
||||
if t.preparedPosts.data.Len() < amount+position {
|
||||
if err := t.PrepareBehind(behindID, false, amount); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
// start serving from the entry right after the mark
|
||||
var served int
|
||||
serveloop:
|
||||
for e := behindIDMark.Next(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*preparedPostsEntry)
|
||||
if !ok {
|
||||
return nil, errors.New("GetXBetweenID: could not parse e as a preparedPostsEntry")
|
||||
}
|
||||
|
||||
if entry.statusID == beforeID {
|
||||
break serveloop
|
||||
}
|
||||
|
||||
// serve up to the amount requested
|
||||
statuses = append(statuses, entry.prepared)
|
||||
served = served + 1
|
||||
if served >= amount {
|
||||
break serveloop
|
||||
}
|
||||
}
|
||||
|
||||
return statuses, nil
|
||||
}
|
||||
120
internal/timeline/index.go
Normal file
120
internal/timeline/index.go
Normal file
@ -0,0 +1,120 @@
|
||||
package timeline
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
func (t *timeline) IndexBefore(statusID string, include bool, amount int) error {
|
||||
// filtered := []*gtsmodel.Status{}
|
||||
// offsetStatus := statusID
|
||||
|
||||
// grabloop:
|
||||
// for len(filtered) < amount {
|
||||
// statuses, err := t.db.GetStatusesWhereFollowing(t.accountID, amount, offsetStatus, include, true)
|
||||
// if err != nil {
|
||||
// if _, ok := err.(db.ErrNoEntries); !ok {
|
||||
// return fmt.Errorf("IndexBeforeAndIncluding: error getting statuses from db: %s", err)
|
||||
// }
|
||||
// break grabloop // we just don't have enough statuses left in the db so index what we've got and then bail
|
||||
// }
|
||||
|
||||
// for _, s := range statuses {
|
||||
// relevantAccounts, err := t.db.PullRelevantAccountsFromStatus(s)
|
||||
// if err != nil {
|
||||
// continue
|
||||
// }
|
||||
// visible, err := t.db.StatusVisible(s, t.account, relevantAccounts)
|
||||
// if err != nil {
|
||||
// continue
|
||||
// }
|
||||
// if visible {
|
||||
// filtered = append(filtered, s)
|
||||
// }
|
||||
// offsetStatus = s.ID
|
||||
// }
|
||||
// }
|
||||
|
||||
// for _, s := range filtered {
|
||||
// if err := t.IndexOne(s.CreatedAt, s.ID); err != nil {
|
||||
// return fmt.Errorf("IndexBeforeAndIncluding: error indexing status with id %s: %s", s.ID, err)
|
||||
// }
|
||||
// }
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t *timeline) IndexBehind(statusID string, include bool, amount int) error {
|
||||
// filtered := []*gtsmodel.Status{}
|
||||
// offsetStatus := statusID
|
||||
|
||||
// grabloop:
|
||||
// for len(filtered) < amount {
|
||||
// statuses, err := t.db.GetStatusesWhereFollowing(t.accountID, amount, offsetStatus, include, false)
|
||||
// if err != nil {
|
||||
// if _, ok := err.(db.ErrNoEntries); !ok {
|
||||
// return fmt.Errorf("IndexBehindAndIncluding: error getting statuses from db: %s", err)
|
||||
// }
|
||||
// break grabloop // we just don't have enough statuses left in the db so index what we've got and then bail
|
||||
// }
|
||||
|
||||
// for _, s := range statuses {
|
||||
// relevantAccounts, err := t.db.PullRelevantAccountsFromStatus(s)
|
||||
// if err != nil {
|
||||
// continue
|
||||
// }
|
||||
// visible, err := t.db.StatusVisible(s, t.account, relevantAccounts)
|
||||
// if err != nil {
|
||||
// continue
|
||||
// }
|
||||
// if visible {
|
||||
// filtered = append(filtered, s)
|
||||
// }
|
||||
// offsetStatus = s.ID
|
||||
// }
|
||||
// }
|
||||
|
||||
// for _, s := range filtered {
|
||||
// if err := t.IndexOne(s.CreatedAt, s.ID); err != nil {
|
||||
// return fmt.Errorf("IndexBehindAndIncluding: error indexing status with id %s: %s", s.ID, err)
|
||||
// }
|
||||
// }
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t *timeline) IndexOneByID(statusID string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t *timeline) IndexOne(statusCreatedAt time.Time, statusID string) error {
|
||||
t.Lock()
|
||||
defer t.Unlock()
|
||||
|
||||
postIndexEntry := &postIndexEntry{
|
||||
createdAt: statusCreatedAt,
|
||||
statusID: statusID,
|
||||
}
|
||||
|
||||
return t.postIndex.insertIndexed(postIndexEntry)
|
||||
}
|
||||
|
||||
func (t *timeline) IndexAndPrepareOne(statusCreatedAt time.Time, statusID string) error {
|
||||
t.Lock()
|
||||
defer t.Unlock()
|
||||
|
||||
postIndexEntry := &postIndexEntry{
|
||||
createdAt: statusCreatedAt,
|
||||
statusID: statusID,
|
||||
}
|
||||
|
||||
if err := t.postIndex.insertIndexed(postIndexEntry); err != nil {
|
||||
return fmt.Errorf("IndexAndPrepareOne: error inserting indexed: %s", err)
|
||||
}
|
||||
|
||||
if err := t.prepare(statusID); err != nil {
|
||||
return fmt.Errorf("IndexAndPrepareOne: error preparing: %s", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
@ -150,7 +150,7 @@ func (m *manager) HomeTimeline(timelineAccountID string, maxID string, sinceID s
|
||||
} else if maxID != "" {
|
||||
statuses, err = t.GetXBehindID(limit, maxID)
|
||||
} else if sinceID != "" {
|
||||
statuses, err = t.GetXBeforeID(limit, sinceID)
|
||||
statuses, err = t.GetXBeforeID(limit, sinceID, true)
|
||||
} else {
|
||||
statuses, err = t.GetXFromTop(limit)
|
||||
}
|
||||
@ -180,7 +180,7 @@ func (m *manager) GetOldestIndexedID(timelineAccountID string) (string, error) {
|
||||
func (m *manager) PrepareXFromTop(timelineAccountID string, limit int) error {
|
||||
t := m.getOrCreateTimeline(timelineAccountID)
|
||||
|
||||
return t.PrepareXFromTop(limit)
|
||||
return t.PrepareFromTop(limit)
|
||||
}
|
||||
|
||||
func (m *manager) WipeStatusFromTimeline(timelineAccountID string, statusID string) (int, error) {
|
||||
|
||||
@ -16,7 +16,6 @@ type postIndexEntry struct {
|
||||
}
|
||||
|
||||
func (p *postIndex) insertIndexed(i *postIndexEntry) error {
|
||||
|
||||
if p.data == nil {
|
||||
p.data = &list.List{}
|
||||
}
|
||||
@ -27,20 +26,33 @@ func (p *postIndex) insertIndexed(i *postIndexEntry) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// we need to iterate through the index to make sure we put this post in the appropriate place according to when it was created
|
||||
var insertMark *list.Element
|
||||
// We need to iterate through the index to make sure we put this post in the appropriate place according to when it was created.
|
||||
// We also need to make sure we're not inserting a duplicate post -- this can happen sometimes and it's not nice UX (*shudder*).
|
||||
for e := p.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*postIndexEntry)
|
||||
if !ok {
|
||||
return errors.New("Remove: could not parse e as a postIndexEntry")
|
||||
return errors.New("index: could not parse e as a postIndexEntry")
|
||||
}
|
||||
|
||||
// if the post to index is newer than e, insert it before e in the list
|
||||
if i.createdAt.After(entry.createdAt) {
|
||||
p.data.InsertBefore(i, e)
|
||||
if insertMark == nil {
|
||||
if i.createdAt.After(entry.createdAt) {
|
||||
insertMark = e
|
||||
}
|
||||
}
|
||||
|
||||
// make sure we don't insert a duplicate
|
||||
if entry.statusID == i.statusID {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
if insertMark != nil {
|
||||
p.data.InsertBefore(i, insertMark)
|
||||
return nil
|
||||
}
|
||||
|
||||
// if we reach this point it's the oldest post we've seen so put it at the back
|
||||
p.data.PushBack(i)
|
||||
return nil
|
||||
|
||||
180
internal/timeline/prepare.go
Normal file
180
internal/timeline/prepare.go
Normal file
@ -0,0 +1,180 @@
|
||||
package timeline
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
"github.com/superseriousbusiness/gotosocial/internal/db"
|
||||
"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
|
||||
)
|
||||
|
||||
func (t *timeline) PrepareBehind(statusID string, include bool, amount int) error {
|
||||
t.Lock()
|
||||
defer t.Unlock()
|
||||
|
||||
var prepared int
|
||||
var preparing bool
|
||||
prepareloop:
|
||||
for e := t.postIndex.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*postIndexEntry)
|
||||
if !ok {
|
||||
return errors.New("PrepareBehind: could not parse e as a postIndexEntry")
|
||||
}
|
||||
|
||||
if !preparing {
|
||||
// we haven't hit the position we need to prepare from yet
|
||||
if entry.statusID == statusID {
|
||||
preparing = true
|
||||
if !include {
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if preparing {
|
||||
if err := t.prepare(entry.statusID); err != nil {
|
||||
// there's been an error
|
||||
if _, ok := err.(db.ErrNoEntries); !ok {
|
||||
// it's a real error
|
||||
return fmt.Errorf("PrepareBehind: error preparing status with id %s: %s", entry.statusID, err)
|
||||
}
|
||||
// the status just doesn't exist (anymore) so continue to the next one
|
||||
continue
|
||||
}
|
||||
if prepared == amount {
|
||||
// we're done
|
||||
break prepareloop
|
||||
}
|
||||
prepared = prepared + 1
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t *timeline) PrepareBefore(statusID string, include bool, amount int) error {
|
||||
t.Lock()
|
||||
defer t.Unlock()
|
||||
|
||||
var prepared int
|
||||
var preparing bool
|
||||
prepareloop:
|
||||
for e := t.postIndex.data.Back(); e != nil; e = e.Prev() {
|
||||
entry, ok := e.Value.(*postIndexEntry)
|
||||
if !ok {
|
||||
return errors.New("PrepareBefore: could not parse e as a postIndexEntry")
|
||||
}
|
||||
|
||||
if !preparing {
|
||||
// we haven't hit the position we need to prepare from yet
|
||||
if entry.statusID == statusID {
|
||||
preparing = true
|
||||
if !include {
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if preparing {
|
||||
if err := t.prepare(entry.statusID); err != nil {
|
||||
// there's been an error
|
||||
if _, ok := err.(db.ErrNoEntries); !ok {
|
||||
// it's a real error
|
||||
return fmt.Errorf("PrepareBefore: error preparing status with id %s: %s", entry.statusID, err)
|
||||
}
|
||||
// the status just doesn't exist (anymore) so continue to the next one
|
||||
continue
|
||||
}
|
||||
if prepared == amount {
|
||||
// we're done
|
||||
break prepareloop
|
||||
}
|
||||
prepared = prepared + 1
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t *timeline) PrepareFromTop(amount int) error {
|
||||
t.Lock()
|
||||
defer t.Unlock()
|
||||
|
||||
t.preparedPosts.data.Init()
|
||||
|
||||
var prepared int
|
||||
prepareloop:
|
||||
for e := t.postIndex.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*postIndexEntry)
|
||||
if !ok {
|
||||
return errors.New("PrepareFromTop: could not parse e as a postIndexEntry")
|
||||
}
|
||||
|
||||
if err := t.prepare(entry.statusID); err != nil {
|
||||
// there's been an error
|
||||
if _, ok := err.(db.ErrNoEntries); !ok {
|
||||
// it's a real error
|
||||
return fmt.Errorf("PrepareFromTop: error preparing status with id %s: %s", entry.statusID, err)
|
||||
}
|
||||
// the status just doesn't exist (anymore) so continue to the next one
|
||||
continue
|
||||
}
|
||||
|
||||
prepared = prepared + 1
|
||||
if prepared == amount {
|
||||
// we're done
|
||||
break prepareloop
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t *timeline) prepare(statusID string) error {
|
||||
|
||||
// start by getting the status out of the database according to its indexed ID
|
||||
gtsStatus := >smodel.Status{}
|
||||
if err := t.db.GetByID(statusID, gtsStatus); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// if the account pointer hasn't been set on this timeline already, set it lazily here
|
||||
if t.account == nil {
|
||||
timelineOwnerAccount := >smodel.Account{}
|
||||
if err := t.db.GetByID(t.accountID, timelineOwnerAccount); err != nil {
|
||||
return err
|
||||
}
|
||||
t.account = timelineOwnerAccount
|
||||
}
|
||||
|
||||
// to convert the status we need relevant accounts from it, so pull them out here
|
||||
relevantAccounts, err := t.db.PullRelevantAccountsFromStatus(gtsStatus)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// check if this is a boost...
|
||||
var reblogOfStatus *gtsmodel.Status
|
||||
if gtsStatus.BoostOfID != "" {
|
||||
s := >smodel.Status{}
|
||||
if err := t.db.GetByID(gtsStatus.BoostOfID, s); err != nil {
|
||||
return err
|
||||
}
|
||||
reblogOfStatus = s
|
||||
}
|
||||
|
||||
// serialize the status (or, at least, convert it to a form that's ready to be serialized)
|
||||
apiModelStatus, err := t.tc.StatusToMasto(gtsStatus, relevantAccounts.StatusAuthor, t.account, relevantAccounts.BoostedAccount, relevantAccounts.ReplyToAccount, reblogOfStatus)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// shove it in prepared posts as a prepared posts entry
|
||||
preparedPostsEntry := &preparedPostsEntry{
|
||||
createdAt: gtsStatus.CreatedAt,
|
||||
statusID: statusID,
|
||||
prepared: apiModelStatus,
|
||||
}
|
||||
|
||||
return t.preparedPosts.insertPrepared(preparedPostsEntry)
|
||||
}
|
||||
@ -29,7 +29,9 @@ func (p *preparedPosts) insertPrepared(i *preparedPostsEntry) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// we need to iterate through the index to make sure we put this post in the appropriate place according to when it was created
|
||||
var insertMark *list.Element
|
||||
// We need to iterate through the index to make sure we put this post in the appropriate place according to when it was created.
|
||||
// We also need to make sure we're not inserting a duplicate post -- this can happen sometimes and it's not nice UX (*shudder*).
|
||||
for e := p.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*preparedPostsEntry)
|
||||
if !ok {
|
||||
@ -37,12 +39,23 @@ func (p *preparedPosts) insertPrepared(i *preparedPostsEntry) error {
|
||||
}
|
||||
|
||||
// if the post to index is newer than e, insert it before e in the list
|
||||
if i.createdAt.After(entry.createdAt) {
|
||||
p.data.InsertBefore(i, e)
|
||||
if insertMark == nil {
|
||||
if i.createdAt.After(entry.createdAt) {
|
||||
insertMark = e
|
||||
}
|
||||
}
|
||||
|
||||
// make sure we don't insert a duplicate
|
||||
if entry.statusID == i.statusID {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
if insertMark != nil {
|
||||
p.data.InsertBefore(i, insertMark)
|
||||
return nil
|
||||
}
|
||||
|
||||
// if we reach this point it's the oldest post we've seen so put it at the back
|
||||
p.data.PushBack(i)
|
||||
return nil
|
||||
|
||||
50
internal/timeline/remove.go
Normal file
50
internal/timeline/remove.go
Normal file
@ -0,0 +1,50 @@
|
||||
package timeline
|
||||
|
||||
import (
|
||||
"container/list"
|
||||
"errors"
|
||||
)
|
||||
|
||||
func (t *timeline) Remove(statusID string) (int, error) {
|
||||
t.Lock()
|
||||
defer t.Unlock()
|
||||
var removed int
|
||||
|
||||
// remove entr(ies) from the post index
|
||||
removeIndexes := []*list.Element{}
|
||||
if t.postIndex != nil && t.postIndex.data != nil {
|
||||
for e := t.postIndex.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*postIndexEntry)
|
||||
if !ok {
|
||||
return removed, errors.New("Remove: could not parse e as a postIndexEntry")
|
||||
}
|
||||
if entry.statusID == statusID {
|
||||
removeIndexes = append(removeIndexes, e)
|
||||
}
|
||||
}
|
||||
}
|
||||
for _, e := range removeIndexes {
|
||||
t.postIndex.data.Remove(e)
|
||||
removed = removed + 1
|
||||
}
|
||||
|
||||
// remove entr(ies) from prepared posts
|
||||
removePrepared := []*list.Element{}
|
||||
if t.preparedPosts != nil && t.preparedPosts.data != nil {
|
||||
for e := t.preparedPosts.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*preparedPostsEntry)
|
||||
if !ok {
|
||||
return removed, errors.New("Remove: could not parse e as a preparedPostsEntry")
|
||||
}
|
||||
if entry.statusID == statusID {
|
||||
removePrepared = append(removePrepared, e)
|
||||
}
|
||||
}
|
||||
}
|
||||
for _, e := range removePrepared {
|
||||
t.preparedPosts.data.Remove(e)
|
||||
removed = removed + 1
|
||||
}
|
||||
|
||||
return removed, nil
|
||||
}
|
||||
@ -19,9 +19,7 @@
|
||||
package timeline
|
||||
|
||||
import (
|
||||
"container/list"
|
||||
"errors"
|
||||
"fmt"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
@ -52,7 +50,7 @@ type Timeline interface {
|
||||
// This will NOT include the status with the given ID.
|
||||
//
|
||||
// This corresponds to an api call to /timelines/home?since_id=WHATEVER
|
||||
GetXBeforeID(amount int, sinceID string) ([]*apimodel.Status, error)
|
||||
GetXBeforeID(amount int, sinceID string, startFromTop bool) ([]*apimodel.Status, error)
|
||||
// GetXBetweenID returns x amount of posts from the given maxID, up to the given id, from newest to oldest.
|
||||
// This will NOT include the status with the given IDs.
|
||||
//
|
||||
@ -80,9 +78,10 @@ type Timeline interface {
|
||||
*/
|
||||
|
||||
// PrepareXFromTop instructs the timeline to prepare x amount of posts from the top of the timeline.
|
||||
PrepareXFromTop(amount int) error
|
||||
// PrepareXFromPosition instrucst the timeline to prepare the next amount of entries for serialization, from position onwards.
|
||||
PrepareXFromPosition(amount int, position int) error
|
||||
PrepareFromTop(amount int) error
|
||||
// PrepareBehind instructs the timeline to prepare the next amount of entries for serialization, from position onwards.
|
||||
// If include is true, then the given status ID will also be prepared, otherwise only entries behind it will be prepared.
|
||||
PrepareBehind(statusID string, include bool, amount int) error
|
||||
// IndexOne puts a status into the timeline at the appropriate place according to its 'createdAt' property,
|
||||
// and then immediately prepares it.
|
||||
IndexAndPrepareOne(statusCreatedAt time.Time, statusID string) error
|
||||
@ -124,280 +123,6 @@ func NewTimeline(accountID string, db db.DB, typeConverter typeutils.TypeConvert
|
||||
}
|
||||
}
|
||||
|
||||
func (t *timeline) PrepareXFromPosition(amount int, desiredPosition int) error {
|
||||
t.Lock()
|
||||
defer t.Unlock()
|
||||
|
||||
var position int
|
||||
var prepared int
|
||||
var preparing bool
|
||||
for e := t.postIndex.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*postIndexEntry)
|
||||
if !ok {
|
||||
return errors.New("PrepareXFromTop: could not parse e as a postIndexEntry")
|
||||
}
|
||||
|
||||
if !preparing {
|
||||
// we haven't hit the position we need to prepare from yet
|
||||
position = position + 1
|
||||
if position == desiredPosition {
|
||||
preparing = true
|
||||
continue
|
||||
}
|
||||
} else {
|
||||
if err := t.prepare(entry.statusID); err != nil {
|
||||
return fmt.Errorf("PrepareXFromTop: error preparing status with id %s: %s", entry.statusID, err)
|
||||
}
|
||||
prepared = prepared + 1
|
||||
if prepared >= amount {
|
||||
// we're done
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t *timeline) PrepareXFromTop(amount int) error {
|
||||
t.Lock()
|
||||
defer t.Unlock()
|
||||
|
||||
t.preparedPosts.data.Init()
|
||||
|
||||
var prepared int
|
||||
for e := t.postIndex.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*postIndexEntry)
|
||||
if !ok {
|
||||
return errors.New("PrepareXFromTop: could not parse e as a postIndexEntry")
|
||||
}
|
||||
|
||||
if err := t.prepare(entry.statusID); err != nil {
|
||||
return fmt.Errorf("PrepareXFromTop: error preparing status with id %s: %s", entry.statusID, err)
|
||||
}
|
||||
|
||||
prepared = prepared + 1
|
||||
if prepared >= amount {
|
||||
// we're done
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t *timeline) GetXFromTop(amount int) ([]*apimodel.Status, error) {
|
||||
// make a slice of statuses with the length we need to return
|
||||
statuses := make([]*apimodel.Status, 0, amount)
|
||||
|
||||
// if there are no prepared posts, just return the empty slice
|
||||
if t.preparedPosts.data == nil {
|
||||
t.preparedPosts.data = &list.List{}
|
||||
}
|
||||
|
||||
// make sure we have enough posts prepared to return
|
||||
if t.preparedPosts.data.Len() < amount {
|
||||
if err := t.PrepareXFromTop(amount); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
// work through the prepared posts from the top and return
|
||||
var served int
|
||||
for e := t.preparedPosts.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*preparedPostsEntry)
|
||||
if !ok {
|
||||
return nil, errors.New("GetXFromTop: could not parse e as a preparedPostsEntry")
|
||||
}
|
||||
statuses = append(statuses, entry.prepared)
|
||||
served = served + 1
|
||||
if served >= amount {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
return statuses, nil
|
||||
}
|
||||
|
||||
func (t *timeline) GetXBehindID(amount int, behindID string) ([]*apimodel.Status, error) {
|
||||
// make a slice of statuses with the length we need to return
|
||||
statuses := make([]*apimodel.Status, 0, amount)
|
||||
|
||||
// if there are no prepared posts, just return the empty slice
|
||||
if t.preparedPosts.data == nil {
|
||||
t.preparedPosts.data = &list.List{}
|
||||
}
|
||||
|
||||
// find the position of id
|
||||
var position int
|
||||
for e := t.preparedPosts.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*preparedPostsEntry)
|
||||
if !ok {
|
||||
return nil, errors.New("GetXBehindID: could not parse e as a preparedPostsEntry")
|
||||
}
|
||||
if entry.statusID == behindID {
|
||||
break
|
||||
}
|
||||
position = position + 1
|
||||
}
|
||||
|
||||
// make sure we have enough posts prepared behind it to return what we're being asked for
|
||||
if t.preparedPosts.data.Len() < amount+position {
|
||||
if err := t.PrepareXFromPosition(amount, position); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
// iterate through the modified list until we hit the fromID again
|
||||
var serving bool
|
||||
var served int
|
||||
for e := t.preparedPosts.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*preparedPostsEntry)
|
||||
if !ok {
|
||||
return nil, errors.New("GetXBehindID: could not parse e as a preparedPostsEntry")
|
||||
}
|
||||
|
||||
if !serving {
|
||||
// start serving if we've hit the id we're looking for
|
||||
if entry.statusID == behindID {
|
||||
serving = true
|
||||
continue
|
||||
}
|
||||
} else {
|
||||
// serve up to the amount requested
|
||||
statuses = append(statuses, entry.prepared)
|
||||
served = served + 1
|
||||
if served >= amount {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return statuses, nil
|
||||
}
|
||||
|
||||
func (t *timeline) GetXBeforeID(amount int, beforeID string) ([]*apimodel.Status, error) {
|
||||
// make a slice of statuses with the length we need to return
|
||||
statuses := make([]*apimodel.Status, 0, amount)
|
||||
|
||||
// if there are no prepared posts, just return the empty slice
|
||||
if t.preparedPosts.data == nil {
|
||||
t.preparedPosts.data = &list.List{}
|
||||
}
|
||||
|
||||
// iterate through the modified list until we hit the fromID again
|
||||
var served int
|
||||
serveloop:
|
||||
for e := t.preparedPosts.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*preparedPostsEntry)
|
||||
if !ok {
|
||||
return nil, errors.New("GetXBeforeID: could not parse e as a preparedPostsEntry")
|
||||
}
|
||||
|
||||
if entry.statusID == beforeID {
|
||||
// we're good
|
||||
break serveloop
|
||||
}
|
||||
|
||||
// serve up to the amount requested
|
||||
statuses = append(statuses, entry.prepared)
|
||||
served = served + 1
|
||||
if served >= amount {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
return statuses, nil
|
||||
}
|
||||
|
||||
func (t *timeline) GetXBetweenID(amount int, maxID string, sinceID string) ([]*apimodel.Status, error) {
|
||||
// make a slice of statuses with the length we need to return
|
||||
statuses := make([]*apimodel.Status, 0, amount)
|
||||
|
||||
// if there are no prepared posts, just return the empty slice
|
||||
if t.preparedPosts.data == nil {
|
||||
t.preparedPosts.data = &list.List{}
|
||||
}
|
||||
|
||||
return statuses, nil
|
||||
}
|
||||
|
||||
func (t *timeline) IndexOne(statusCreatedAt time.Time, statusID string) error {
|
||||
t.Lock()
|
||||
defer t.Unlock()
|
||||
|
||||
postIndexEntry := &postIndexEntry{
|
||||
createdAt: statusCreatedAt,
|
||||
statusID: statusID,
|
||||
}
|
||||
|
||||
return t.postIndex.insertIndexed(postIndexEntry)
|
||||
}
|
||||
|
||||
func (t *timeline) IndexAndPrepareOne(statusCreatedAt time.Time, statusID string) error {
|
||||
t.Lock()
|
||||
defer t.Unlock()
|
||||
|
||||
postIndexEntry := &postIndexEntry{
|
||||
createdAt: statusCreatedAt,
|
||||
statusID: statusID,
|
||||
}
|
||||
|
||||
if err := t.postIndex.insertIndexed(postIndexEntry); err != nil {
|
||||
return fmt.Errorf("IndexAndPrepareOne: error inserting indexed: %s", err)
|
||||
}
|
||||
|
||||
if err := t.prepare(statusID); err != nil {
|
||||
return fmt.Errorf("IndexAndPrepareOne: error preparing: %s", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t *timeline) Remove(statusID string) (int, error) {
|
||||
t.Lock()
|
||||
defer t.Unlock()
|
||||
var removed int
|
||||
|
||||
// remove entr(ies) from the post index
|
||||
removeIndexes := []*list.Element{}
|
||||
if t.postIndex != nil && t.postIndex.data != nil {
|
||||
for e := t.postIndex.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*postIndexEntry)
|
||||
if !ok {
|
||||
return removed, errors.New("Remove: could not parse e as a postIndexEntry")
|
||||
}
|
||||
if entry.statusID == statusID {
|
||||
removeIndexes = append(removeIndexes, e)
|
||||
}
|
||||
}
|
||||
}
|
||||
for _, e := range removeIndexes {
|
||||
t.postIndex.data.Remove(e)
|
||||
removed = removed + 1
|
||||
}
|
||||
|
||||
// remove entr(ies) from prepared posts
|
||||
removePrepared := []*list.Element{}
|
||||
if t.preparedPosts != nil && t.preparedPosts.data != nil {
|
||||
for e := t.preparedPosts.data.Front(); e != nil; e = e.Next() {
|
||||
entry, ok := e.Value.(*preparedPostsEntry)
|
||||
if !ok {
|
||||
return removed, errors.New("Remove: could not parse e as a preparedPostsEntry")
|
||||
}
|
||||
if entry.statusID == statusID {
|
||||
removePrepared = append(removePrepared, e)
|
||||
}
|
||||
}
|
||||
}
|
||||
for _, e := range removePrepared {
|
||||
t.preparedPosts.data.Remove(e)
|
||||
removed = removed + 1
|
||||
}
|
||||
|
||||
return removed, nil
|
||||
}
|
||||
|
||||
func (t *timeline) Reset() error {
|
||||
return nil
|
||||
}
|
||||
@ -430,52 +155,3 @@ func (t *timeline) OldestIndexedPostID() (string, error) {
|
||||
}
|
||||
return entry.statusID, nil
|
||||
}
|
||||
|
||||
func (t *timeline) prepare(statusID string) error {
|
||||
|
||||
// start by getting the status out of the database according to its indexed ID
|
||||
gtsStatus := >smodel.Status{}
|
||||
if err := t.db.GetByID(statusID, gtsStatus); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// if the account pointer hasn't been set on this timeline already, set it lazily here
|
||||
if t.account == nil {
|
||||
timelineOwnerAccount := >smodel.Account{}
|
||||
if err := t.db.GetByID(t.accountID, timelineOwnerAccount); err != nil {
|
||||
return err
|
||||
}
|
||||
t.account = timelineOwnerAccount
|
||||
}
|
||||
|
||||
// to convert the status we need relevant accounts from it, so pull them out here
|
||||
relevantAccounts, err := t.db.PullRelevantAccountsFromStatus(gtsStatus)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// check if this is a boost...
|
||||
var reblogOfStatus *gtsmodel.Status
|
||||
if gtsStatus.BoostOfID != "" {
|
||||
s := >smodel.Status{}
|
||||
if err := t.db.GetByID(gtsStatus.BoostOfID, s); err != nil {
|
||||
return err
|
||||
}
|
||||
reblogOfStatus = s
|
||||
}
|
||||
|
||||
// serialize the status (or, at least, convert it to a form that's ready to be serialized)
|
||||
apiModelStatus, err := t.tc.StatusToMasto(gtsStatus, relevantAccounts.StatusAuthor, t.account, relevantAccounts.BoostedAccount, relevantAccounts.ReplyToAccount, reblogOfStatus)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// shove it in prepared posts as a prepared posts entry
|
||||
preparedPostsEntry := &preparedPostsEntry{
|
||||
createdAt: gtsStatus.CreatedAt,
|
||||
statusID: statusID,
|
||||
prepared: apiModelStatus,
|
||||
}
|
||||
|
||||
return t.preparedPosts.insertPrepared(preparedPostsEntry)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user