incoming UNDO for follows now working

internal/federation/federating_db.go

@@ -38,6 +38,11 @@ import (
 	"github.com/superseriousbusiness/gotosocial/internal/util"
 )
 
+type FederatingDB interface {
+	pub.Database
+	Undo(c context.Context, asType vocab.Type) error
+}
+
 // FederatingDB uses the underlying DB interface to implement the go-fed pub.Database interface.
 // It doesn't care what the underlying implementation of the DB interface is, as long as it works.
 type federatingDB struct {
@@ -48,8 +53,8 @@ type federatingDB struct {
 	typeConverter typeutils.TypeConverter
 }
 
-// NewFederatingDB returns a pub.Database interface using the given database, config, and logger.
-func NewFederatingDB(db db.DB, config *config.Config, log *logrus.Logger) pub.Database {
+// NewFederatingDB returns a FederatingDB interface using the given database, config, and logger.
+func NewFederatingDB(db db.DB, config *config.Config, log *logrus.Logger) FederatingDB {
 	return &federatingDB{
 		locks:         new(sync.Map),
 		db:            db,
@@ -405,7 +410,7 @@ func (f *federatingDB) Create(ctx context.Context, asType vocab.Type) error {
 		return nil
 	}
 
-	switch gtsmodel.ActivityStreamsActivity(asType.GetTypeName()) {
+	switch asType.GetTypeName() {
 	case gtsmodel.ActivityStreamsCreate:
 		create, ok := asType.(vocab.ActivityStreamsCreate)
 		if !ok {
@@ -413,7 +418,7 @@ func (f *federatingDB) Create(ctx context.Context, asType vocab.Type) error {
 		}
 		object := create.GetActivityStreamsObject()
 		for objectIter := object.Begin(); objectIter != object.End(); objectIter = objectIter.Next() {
-			switch gtsmodel.ActivityStreamsObject(objectIter.GetType().GetTypeName()) {
+			switch objectIter.GetType().GetTypeName() {
 			case gtsmodel.ActivityStreamsNote:
 				note := objectIter.GetActivityStreamsNote()
 				status, err := f.typeConverter.ASStatusToStatus(note)
@@ -425,9 +430,10 @@ func (f *federatingDB) Create(ctx context.Context, asType vocab.Type) error {
 				}
 
 				fromFederatorChan <- gtsmodel.FromFederator{
-					APObjectType:   gtsmodel.ActivityStreamsNote,
-					APActivityType: gtsmodel.ActivityStreamsCreate,
-					GTSModel:       status,
+					APObjectType:     gtsmodel.ActivityStreamsNote,
+					APActivityType:   gtsmodel.ActivityStreamsCreate,
+					GTSModel:         status,
+					ReceivingAccount: targetAcct,
 				}
 			}
 		}
@@ -455,6 +461,98 @@ func (f *federatingDB) Create(ctx context.Context, asType vocab.Type) error {
 	return nil
 }
 
+func (f *federatingDB) Undo(ctx context.Context, asType vocab.Type) error {
+	l := f.log.WithFields(
+		logrus.Fields{
+			"func":   "Undo",
+			"asType": asType.GetTypeName(),
+		},
+	)
+	m, err := streams.Serialize(asType)
+	if err != nil {
+		return err
+	}
+	b, err := json.Marshal(m)
+	if err != nil {
+		return err
+	}
+	l.Debugf("received UNDO asType %s", string(b))
+
+	targetAcctI := ctx.Value(util.APAccount)
+	if targetAcctI == nil {
+		l.Error("UNDO: target account wasn't set on context")
+		return nil
+	}
+	targetAcct, ok := targetAcctI.(*gtsmodel.Account)
+	if !ok {
+		l.Error("UNDO: target account was set on context but couldn't be parsed")
+		return nil
+	}
+
+	// fromFederatorChanI := ctx.Value(util.APFromFederatorChanKey)
+	// if fromFederatorChanI == nil {
+	// 	l.Error("from federator channel wasn't set on context")
+	// 	return nil
+	// }
+	// fromFederatorChan, ok := fromFederatorChanI.(chan gtsmodel.FromFederator)
+	// if !ok {
+	// 	l.Error("from federator channel was set on context but couldn't be parsed")
+	// 	return nil
+	// }
+
+	switch asType.GetTypeName() {
+	// UNDO
+	case gtsmodel.ActivityStreamsUndo:
+		undo, ok := asType.(vocab.ActivityStreamsUndo)
+		if !ok {
+			return errors.New("UNDO: couldn't parse UNDO into vocab.ActivityStreamsUndo")
+		}
+		undoObject := undo.GetActivityStreamsObject()
+		if undoObject == nil {
+			return errors.New("UNDO: no object set on vocab.ActivityStreamsUndo")
+		}
+
+		for iter := undoObject.Begin(); iter != undoObject.End(); iter = iter.Next() {
+			switch iter.GetType().GetTypeName() {
+			case string(gtsmodel.ActivityStreamsFollow):
+				// UNDO FOLLOW
+				ASFollow, ok := iter.GetType().(vocab.ActivityStreamsFollow)
+				if !ok {
+					return errors.New("UNDO: couldn't parse follow into vocab.ActivityStreamsFollow")
+				}
+				// make sure the actor owns the follow
+				if !sameActor(undo.GetActivityStreamsActor(), ASFollow.GetActivityStreamsActor()) {
+					return errors.New("UNDO: follow actor and activity actor not the same")
+				}
+				// convert the follow to something we can understand
+				gtsFollow, err := f.typeConverter.ASFollowToFollow(ASFollow)
+				if err != nil {
+					return fmt.Errorf("UNDO: error converting asfollow to gtsfollow: %s", err)
+				}
+				// make sure the addressee of the original follow is the same as whatever inbox this landed in
+				if gtsFollow.TargetAccountID != targetAcct.ID {
+					return errors.New("UNDO: follow object account and inbox account were not the same")
+				}
+				// delete any existing FOLLOW
+				if err := f.db.DeleteWhere("uri", gtsFollow.URI, &gtsmodel.Follow{}); err != nil {
+					return fmt.Errorf("UNDO: db error removing follow: %s", err)
+				}
+				// delete any existing FOLLOW REQUEST
+				if err := f.db.DeleteWhere("uri", gtsFollow.URI, &gtsmodel.FollowRequest{}); err != nil {
+					return fmt.Errorf("UNDO: db error removing follow request: %s", err)
+				}
+				l.Debug("follow undone")
+				return nil
+			case string(gtsmodel.ActivityStreamsLike):
+				// UNDO LIKE
+			case string(gtsmodel.ActivityStreamsAnnounce):
+				// UNDO BOOST/REBLOG/ANNOUNCE
+			}
+		}
+	}
+	return nil
+}
+
 // Update sets an existing entry to the database based on the value's
 // id.
 //
@@ -500,7 +598,7 @@ func (f *federatingDB) Update(ctx context.Context, asType vocab.Type) error {
 		l.Error("from federator channel was set on context but couldn't be parsed")
 	}
 
-	switch gtsmodel.ActivityStreamsActivity(asType.GetTypeName()) {
+	switch asType.GetTypeName() {
 	case gtsmodel.ActivityStreamsUpdate:
 		update, ok := asType.(vocab.ActivityStreamsCreate)
 		if !ok {

internal/federation/federatingprotocol.go

@@ -20,14 +20,12 @@ package federation
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
 	"net/url"
 
 	"github.com/go-fed/activity/pub"
-	"github.com/go-fed/activity/streams"
 	"github.com/go-fed/activity/streams/vocab"
 	"github.com/sirupsen/logrus"
 	"github.com/superseriousbusiness/gotosocial/internal/db"
@@ -271,7 +269,7 @@ func (f *federator) FederatingCallbacks(ctx context.Context) (wrapped pub.Federa
 	// override default undo behavior
 	other = []interface{}{
 		func(ctx context.Context, undo vocab.ActivityStreamsUndo) error {
-			return f.typeConverter.
+			return f.FederatingDB().Undo(ctx, undo)
 		},
 	}
 

internal/federation/federator.go

@@ -52,6 +52,7 @@ type Federator interface {
 type federator struct {
 	config              *config.Config
 	db                  db.DB
+	federatingDB        FederatingDB
 	clock               pub.Clock
 	typeConverter       typeutils.TypeConverter
 	transportController transport.Controller
@@ -60,18 +61,19 @@ type federator struct {
 }
 
 // NewFederator returns a new federator
-func NewFederator(db db.DB, transportController transport.Controller, config *config.Config, log *logrus.Logger, typeConverter typeutils.TypeConverter) Federator {
+func NewFederator(db db.DB, federatingDB FederatingDB, transportController transport.Controller, config *config.Config, log *logrus.Logger, typeConverter typeutils.TypeConverter) Federator {
 
 	clock := &Clock{}
 	f := &federator{
 		config:              config,
 		db:                  db,
+		federatingDB:        federatingDB,
 		clock:               &Clock{},
 		typeConverter:       typeConverter,
 		transportController: transportController,
 		log:                 log,
 	}
-	actor := newFederatingActor(f, f, db.Federation(), clock)
+	actor := newFederatingActor(f, f, federatingDB, clock)
 	f.actor = actor
 	return f
 }
@@ -79,3 +81,7 @@ func NewFederator(db db.DB, transportController transport.Controller, config *co
 func (f *federator) FederatingActor() pub.FederatingActor {
 	return f.actor
 }
+
+func (f *federator) FederatingDB() FederatingDB {
+	return f.federatingDB
+}

internal/federation/federator_test.go

@@ -89,7 +89,7 @@ func (suite *ProtocolTestSuite) TestPostInboxRequestBodyHook() {
 		return nil, nil
 	}))
 	// setup module being tested
-	federator := federation.NewFederator(suite.db, tc, suite.config, suite.log, suite.typeConverter)
+	federator := federation.NewFederator(suite.db, testrig.NewTestFederatingDB(suite.db), tc, suite.config, suite.log, suite.typeConverter)
 
 	// setup request
 	ctx := context.Background()
@@ -155,7 +155,7 @@ func (suite *ProtocolTestSuite) TestAuthenticatePostInbox() {
 	}))
 
 	// now setup module being tested, with the mock transport controller
-	federator := federation.NewFederator(suite.db, tc, suite.config, suite.log, suite.typeConverter)
+	federator := federation.NewFederator(suite.db, testrig.NewTestFederatingDB(suite.db), tc, suite.config, suite.log, suite.typeConverter)
 
 	// setup request
 	ctx := context.Background()

internal/federation/util.go

@@ -243,3 +243,23 @@ func (f *federator) GetTransportForUser(username string) (transport.Transport, e
 	}
 	return transport, nil
 }
+
+func sameActor(activityActor vocab.ActivityStreamsActorProperty, followActor vocab.ActivityStreamsActorProperty) bool {
+	if activityActor == nil || followActor == nil {
+		return false
+	}
+	for aIter := activityActor.Begin(); aIter != activityActor.End(); aIter = aIter.Next() {
+		for fIter := followActor.Begin(); fIter != followActor.End(); fIter = fIter.Next() {
+			if aIter.GetIRI() == nil {
+				return false
+			}
+			if fIter.GetIRI() == nil {
+				return false
+			}
+			if aIter.GetIRI().String() == fIter.GetIRI().String() {
+				return true
+			}
+		}
+	}
+	return false
+}