hup hup hup allee

internal/message/apuserprocess.go

@@ -1,70 +0,0 @@
-package message
-
-import (
-	"fmt"
-	"net/http"
-
-	"github.com/go-fed/activity/streams"
-	"github.com/superseriousbusiness/gotosocial/internal/db"
-	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
-)
-
-func (p *processor) GetAPUser(requestedUsername string, request *http.Request) (interface{}, ErrorWithCode) {
-	// get the account the request is referring to
-	requestedAccount := &gtsmodel.Account{}
-	if err := p.db.GetLocalAccountByUsername(requestedUsername, requestedAccount); err != nil {
-		return nil, NewErrorNotFound(fmt.Errorf("database error getting account with username %s: %s", requestedUsername, err))
-	}
-
-	// authenticate the request
-	requestingAccountURI, err := p.federator.AuthenticateFederatedRequest(requestedUsername, request)
-	if err != nil {
-		return nil, NewErrorNotAuthorized(err)
-	}
-
-	requestingAccount := &gtsmodel.Account{}
-	err = p.db.GetWhere("uri", requestingAccountURI.String(), requestingAccount)
-	if err != nil {
-		if _, ok := err.(db.ErrNoEntries); !ok {
-			// we don't have an entry for this account yet
-			// what we do now should depend on our chosen federation method
-			// for now though, we'll just dereference it
-			// TODO: slow-fed
-			requestingPerson, err := p.federator.DereferenceRemoteAccount(requestedUsername, requestingAccountURI)
-			if err != nil {
-				return nil, NewErrorInternalError(err)
-			}
-			requestedAccount, err = p.tc.ASPersonToAccount(requestingPerson)
-			if err != nil {
-				return nil, NewErrorInternalError(err)
-			}
-			if err := p.db.Put(requestingAccount); err != nil {
-				return nil, NewErrorInternalError(err)
-			}
-		} else {
-			// something has actually gone wrong
-			return nil, NewErrorInternalError(err)
-		}
-	}
-
-	blocked, err := p.db.Blocked(requestedAccount.ID, requestingAccount.ID)
-	if err != nil {
-		return nil, NewErrorInternalError(err)
-	}
-
-	if blocked {
-		return nil, NewErrorNotAuthorized(fmt.Errorf("block exists between accounts %s and %s", requestedAccount.ID, requestingAccount.ID))
-	}
-
-	requestedPerson, err := p.tc.AccountToAS(requestedAccount)
-	if err != nil {
-		return nil, NewErrorInternalError(err)
-	}
-
-	data, err := streams.Serialize(requestedPerson)
-	if err != nil {
-		return nil, NewErrorInternalError(err)
-	}
-
-	return data, nil
-}

internal/message/fediprocess.go

@@ -0,0 +1,102 @@
+package message
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/go-fed/activity/streams"
+	"github.com/superseriousbusiness/gotosocial/internal/db"
+	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
+)
+
+// authenticateAndDereferenceFediRequest authenticates the HTTP signature of an incoming federation request, using the given
+// username to perform the validation. It will *also* dereference the originator of the request and return it as a gtsmodel account
+// for further processing. NOTE that this function will have the side effect of putting the dereferenced account into the database,
+// and passing it into the processor through a channel for further asynchronous processing.
+func (p *processor) authenticateAndDereferenceFediRequest(username string, r *http.Request) (*gtsmodel.Account, error) {
+
+	// first authenticate
+	requestingAccountURI, err := p.federator.AuthenticateFederatedRequest(username, r)
+	if err != nil {
+		return nil, fmt.Errorf("couldn't authenticate request for username %s: %s", username, err)
+	}
+
+	// OK now we can do the dereferencing part
+	// we might already have an entry for this account so check that first
+	requestingAccount := &gtsmodel.Account{}
+
+	err = p.db.GetWhere("uri", requestingAccountURI.String(), requestingAccount)
+	if err == nil {
+		// we do have it yay, return it
+		return requestingAccount, nil
+	}
+
+	if _, ok := err.(db.ErrNoEntries); !ok {
+		// something has actually gone wrong so bail
+		return nil, fmt.Errorf("database error getting account with uri %s: %s", requestingAccountURI.String(), err)
+	}
+
+	// we just don't have an entry for this account yet
+	// what we do now should depend on our chosen federation method
+	// for now though, we'll just dereference it
+	// TODO: slow-fed
+	requestingPerson, err := p.federator.DereferenceRemoteAccount(username, requestingAccountURI)
+	if err != nil {
+		return nil, fmt.Errorf("couldn't dereference %s: %s", requestingAccountURI.String(), err)
+	}
+
+	// convert it to our internal account representation
+	requestingAccount, err = p.tc.ASPersonToAccount(requestingPerson)
+	if err != nil {
+		return nil, fmt.Errorf("couldn't convert dereferenced uri %s to gtsmodel account: %s", requestingAccountURI.String(), err)
+	}
+
+	// shove it in the database for later
+	if err := p.db.Put(requestingAccount); err != nil {
+		return nil, fmt.Errorf("database error inserting account with uri %s: %s", requestingAccountURI.String(), err)
+	}
+
+	// put it in our channel to queue it for async processing
+	p.FromFederator() <- FromFederator{
+		APObjectType:   gtsmodel.ActivityStreamsProfile,
+		APActivityType: gtsmodel.ActivityStreamsCreate,
+		Activity:       requestingAccount,
+	}
+
+	return requestingAccount, nil
+}
+
+func (p *processor) GetFediUser(requestedUsername string, request *http.Request) (interface{}, ErrorWithCode) {
+	// get the account the request is referring to
+	requestedAccount := &gtsmodel.Account{}
+	if err := p.db.GetLocalAccountByUsername(requestedUsername, requestedAccount); err != nil {
+		return nil, NewErrorNotFound(fmt.Errorf("database error getting account with username %s: %s", requestedUsername, err))
+	}
+
+	// authenticate the request
+	requestingAccount, err := p.authenticateAndDereferenceFediRequest(requestedUsername, request)
+	if err != nil {
+		return nil, NewErrorNotAuthorized(err)
+	}
+
+	blocked, err := p.db.Blocked(requestedAccount.ID, requestingAccount.ID)
+	if err != nil {
+		return nil, NewErrorInternalError(err)
+	}
+
+	if blocked {
+		return nil, NewErrorNotAuthorized(fmt.Errorf("block exists between accounts %s and %s", requestedAccount.ID, requestingAccount.ID))
+	}
+
+	requestedPerson, err := p.tc.AccountToAS(requestedAccount)
+	if err != nil {
+		return nil, NewErrorInternalError(err)
+	}
+
+	data, err := streams.Serialize(requestedPerson)
+	if err != nil {
+		return nil, NewErrorInternalError(err)
+	}
+
+	return data, nil
+}

internal/message/processor.go

@@ -46,8 +46,12 @@ type Processor interface {
 	FromClientAPI() chan FromClientAPI
 	// ToFederator returns a channel for putting in messages that need to go to the federator (activitypub).
 	ToFederator() chan ToFederator
-	// FromFederator returns a channel for putting messages in that come from the federator going into the processor
+	// FromFederator returns a channel for putting messages in that come from the federator (activitypub) going into the processor
 	FromFederator() chan FromFederator
+	// Start starts the Processor, reading from its channels and passing messages back and forth.
+	Start() error
+	// Stop stops the processor cleanly, finishing handling any remaining messages before closing down.
+	Stop() error
 
 	/*
 		CLIENT API-FACING PROCESSING FUNCTIONS
@@ -80,6 +84,7 @@ type Processor interface {
 
 	// MediaCreate handles the creation of a media attachment, using the given form.
 	MediaCreate(authed *oauth.Auth, form *apimodel.AttachmentRequest) (*apimodel.Attachment, error)
+	// MediaGet handles the fetching of a media attachment, using the given request form.
 	MediaGet(authed *oauth.Auth, form *apimodel.GetContentRequestForm) (*apimodel.Content, error)
 	// AdminEmojiCreate handles the creation of a new instance emoji by an admin, using the given form.
 	AdminEmojiCreate(authed *oauth.Auth, form *apimodel.EmojiCreateRequest) (*apimodel.Emoji, error)
@@ -92,12 +97,12 @@ type Processor interface {
 		response, pass work to the processor using a channel instead.
 	*/
 
-	GetAPUser(requestedUsername string, request *http.Request) (interface{}, ErrorWithCode)
+	// GetFediUser handles the getting of a fedi/activitypub representation of a user/account, performing appropriate authentication
+	// before returning a JSON serializable interface to the caller.
+	GetFediUser(requestedUsername string, request *http.Request) (interface{}, ErrorWithCode)
+
+	
 
-	// Start starts the Processor, reading from its channels and passing messages back and forth.
-	Start() error
-	// Stop stops the processor cleanly, finishing handling any remaining messages before closing down.
-	Stop() error
 }
 
 // processor just implements the Processor interface
@@ -161,8 +166,12 @@ func (p *processor) Start() error {
 			select {
 			case clientMsg := <-p.toClientAPI:
 				p.log.Infof("received message TO client API: %+v", clientMsg)
+			case clientMsg := <-p.fromClientAPI:
+				p.log.Infof("received message FROM client API: %+v", clientMsg)
 			case federatorMsg := <-p.toFederator:
 				p.log.Infof("received message TO federator: %+v", federatorMsg)
+			case federatorMsg := <-p.fromFederator:
+				p.log.Infof("received message FROM federator: %+v", federatorMsg)
 			case <-p.stop:
 				break DistLoop
 			}