Documentation ¶
Index ¶
- Constants
- Variables
- func AcceptActivity(p P, act *vocab.Activity, receivedIn vocab.IRI) (*vocab.Activity, error)
- func AppreciationActivity(p P, act *vocab.Activity) (*vocab.Activity, error)
- func BlockActivity(p P, act *vocab.Activity, receivedIn vocab.IRI) (*vocab.Activity, error)
- func CollectionManagementActivity(l WriteStore, act *vocab.Activity) (*vocab.Activity, error)
- func ContentExperienceActivity(l WriteStore, act *vocab.Activity) (*vocab.Activity, error)
- func ContentManagementActivityFromClient(p P, act *vocab.Activity) (*vocab.Activity, error)
- func CreateActivityFromClient(p P, act *vocab.Activity) (*vocab.Activity, error)
- func CreateActivityFromServer(p P, act *vocab.Activity) (*vocab.Activity, error)
- func DeleteActivity(l WriteStore, act *vocab.Activity) (*vocab.Activity, error)
- func EventRSVPActivity(l WriteStore, act *vocab.Activity) (*vocab.Activity, error)
- func FilterItem(i vocab.Item) itemFilter
- func FlagActivity(l WriteStore, act *vocab.Activity) (*vocab.Activity, error)
- func FollowActivity(p P, act *vocab.Activity, receivedIn vocab.IRI) (*vocab.Activity, error)
- func GeoSocialEventsActivity(l WriteStore, act *vocab.Activity) (*vocab.Activity, error)
- func GeoSocialEventsIntransitiveActivity(l WriteStore, act *vocab.IntransitiveActivity) (*vocab.IntransitiveActivity, error)
- func GroupManagementActivity(l WriteStore, act *vocab.Activity) (*vocab.Activity, error)
- func IRIBelongsToActor(iri vocab.IRI, actor vocab.Actor) bool
- func IgnoreActivity(p P, act *vocab.Activity) (*vocab.Activity, error)
- func IsInbox(i vocab.IRI) bool
- func IsOutbox(i vocab.IRI) bool
- func NegatingActivity(l Store, act *vocab.Activity) (*vocab.Activity, error)
- func NotificationActivity(l WriteStore, act *vocab.Activity) (*vocab.Activity, error)
- func ObjectNotUpdatedSince(h http.Header, it vocab.Item) bool
- func OffersActivity(l WriteStore, act *vocab.Activity) (*vocab.Activity, error)
- func QuestionActivity(l WriteStore, q *vocab.Question) (*vocab.Question, error)
- func ReactionsActivity(p P, act *vocab.Activity, receivedIn vocab.IRI) (*vocab.Activity, error)
- func RejectActivity(l WriteStore, act *vocab.Activity) (*vocab.Activity, error)
- func RelationshipManagementActivity(p P, act *vocab.Activity, receivedIn vocab.IRI) (*vocab.Activity, error)
- func SetIDIfMissing(it vocab.Item, partOf vocab.Item, parentActivity vocab.Item) error
- func UndoActivity(r Store, act *vocab.Activity) (*vocab.Activity, error)
- func UndoAppreciationActivity(r Store, act *vocab.Activity) (*vocab.Activity, error)
- func UndoRelationshipManagementActivity(r WriteStore, act *vocab.Activity) (*vocab.Activity, error)
- func UpdateActivity(l WriteStore, act *vocab.Activity) (*vocab.Activity, error)
- func ValidateClientCollectionManagementActivity(l ReadStore, act *vocab.Activity) error
- func ValidateClientContentExperienceActivity(l ReadStore, act *vocab.Activity) error
- func ValidateClientContentManagementActivity(l ReadStore, act *vocab.Activity) error
- func ValidateClientEventRSVPActivity(l ReadStore, act *vocab.Activity) error
- func ValidateClientGeoSocialEventsActivity(l ReadStore, act *vocab.Activity) error
- func ValidateClientGroupManagementActivity(l ReadStore, act *vocab.Activity) error
- func ValidateClientNegatingActivity(l ReadStore, act *vocab.Activity) error
- func ValidateClientNotificationActivity(l ReadStore, act *vocab.Activity) error
- func ValidateClientOffersActivity(l ReadStore, act *vocab.Activity) error
- func ValidateClientQuestionActivity(l ReadStore, act *vocab.Question) error
- func ValidateClientReactionsActivity(l ReadStore, act *vocab.Activity) error
- func ValidateClientRelationshipManagementActivity(l ReadStore, act *vocab.Activity) error
- type ActivityHandlerFn
- type ActivityValidator
- type ActorValidator
- type C2SProcessor
- type ClientActivityValidator
- type CollectionHandlerFn
- type CollectionStore
- type CollectionTyper
- type Filterable
- type FilterableActivity
- type FilterableCollection
- type FilterableItems
- type FilterableObject
- type IDGenerator
- type IRIValidator
- type ItemHandlerFn
- type KeyLoader
- type Metadata
- type MethodValidator
- type ObjectValidator
- type OptionFn
- func WithActorKeyGenerator(genFn vocab.WithActorFn) OptionFn
- func WithClient(c c.Basic) OptionFn
- func WithIDGenerator(genFn IDGenerator) OptionFn
- func WithIRI(i ...vocab.IRI) OptionFn
- func WithLocalIRIChecker(isLocalFn IRIValidator) OptionFn
- func WithLogger(l lw.Logger) OptionFn
- func WithStorage(s Store) OptionFn
- type P
- func (p P) AddItemToCollection(col vocab.IRI, it vocab.Item) error
- func (p P) AddToLocalCollections(it vocab.Item, recipients ...vocab.Item) error
- func (p P) AddToRemoteCollections(it vocab.Item, recipients ...vocab.Item) error
- func (p P) BuildInboxRecipientsList(it vocab.Item, receivedIn vocab.IRI) (vocab.ItemCollection, error)
- func (p P) BuildOutboxRecipientsList(it vocab.Item, receivedIn vocab.IRI) (vocab.ItemCollection, error)
- func (p P) BuildReplyToCollections(it vocab.Item) (vocab.ItemCollection, error)
- func (p P) CreateCollectionsForObject(it vocab.Item) error
- func (p P) IsLocal(i vocab.Item) bool
- func (p P) IsLocalIRI(i vocab.IRI) bool
- func (p P) ProcessActivity(it vocab.Item, author vocab.Actor, receivedIn vocab.IRI) (vocab.Item, error)
- func (p P) ProcessClientActivity(it vocab.Item, author vocab.Actor, receivedIn vocab.IRI) (vocab.Item, error)
- func (p P) ProcessOutboxDelivery(it vocab.Item, receivedIn vocab.IRI) error
- func (p P) ProcessServerActivity(it vocab.Item, author vocab.Actor, receivedIn vocab.IRI) (vocab.Item, error)
- func (p P) ProcessServerInboxDelivery(it vocab.Item, receivedIn vocab.IRI) error
- func (p P) ValidateActivity(a vocab.Item, author vocab.Actor, receivedIn vocab.IRI) error
- func (p P) ValidateActor(a vocab.Item, expected vocab.Actor) (vocab.Item, error)
- func (p P) ValidateAudience(audience ...vocab.ItemCollection) error
- func (p P) ValidateClientActivity(a vocab.Item, author vocab.Actor, outbox vocab.IRI) error
- func (p P) ValidateClientActor(a vocab.Item, expected vocab.Actor) (vocab.Item, error)
- func (p P) ValidateClientObject(o vocab.Item) (vocab.Item, error)
- func (p P) ValidateIRI(i vocab.IRI) error
- func (p P) ValidateServerActivity(a vocab.Item, author vocab.Actor, inbox vocab.IRI) error
- func (p P) ValidateServerActor(a vocab.Item, expected vocab.Actor) (vocab.Item, error)
- func (p P) ValidateServerObject(o vocab.Item) (vocab.Item, error)
- func (p P) ValidateTarget(t vocab.Item) error
- type ReadStore
- type RequestValidator
- type S2SProcessor
- type ServerActivityValidator
- type Store
- type Validator
- type WriteStore
Constants ¶
const BlockedCollection = vocab.CollectionPath("blocked")
const IgnoredCollection = vocab.CollectionPath("ignored")
const OAuthOOBRedirectURN = "urn:ietf:wg:oauth:2.0:oob:auto"
Variables ¶
var ErrDuplicateObject = func(s string, p ...interface{}) errDuplicateKey { return errDuplicateKey{wrapErr(nil, fmt.Sprintf("Duplicate key: %s", s), p...)} }
var InvalidActivity = func(s string, p ...interface{}) error { return ValidationError(fmt.Sprintf("Activity is not valid: %s", s), p...) }
var InvalidActivityActor = func(s string, p ...interface{}) error { return ValidationError(fmt.Sprintf("Actor is not valid: %s", s), p...) }
var InvalidActivityObject = func(s string, p ...interface{}) error { return ValidationError(fmt.Sprintf("Object is not valid: %s", s), p...) }
var InvalidIRI = func(s string, p ...interface{}) error { return ValidationError(fmt.Sprintf("IRI is not valid: %s", s), p...) }
var InvalidTarget = func(s string, p ...interface{}) error { return ValidationError(fmt.Sprintf("Target is not valid: %s", s), p...) }
var MissingActivityActor = func(s string, p ...interface{}) error { return ValidationError(fmt.Sprintf("Missing actor %s", s), p...) }
var NotModified = errors.NotModified("from cache")
var ValidationError = errors.BadRequestf
Functions ¶
func AcceptActivity ¶
AcceptActivity
In Inbox: https://www.w3.org/TR/activitypub/#follow-activity-inbox
The side effect of receiving this in an inbox is determined by the type of the object received, and it is possible to accept types not described in this document (for example, an Offer).
If the object of an Accept received to an inbox is a Follow activity previously sent by the receiver, the server SHOULD add the actor to the receiver's Following Collection.
func AppreciationActivity ¶
AppreciationActivity The Like(and Dislike) activity indicates the actor likes the object. The side effect of receiving this in an outbox is that the server SHOULD add the object to the actor's liked Collection.
func BlockActivity ¶
BlockActivity
https://www.w3.org/TR/activitypub/#block-activity-outbox
The Block activity is used to indicate that the posting actor does not want another actor (defined in the object property) to be able to interact with objects posted by the actor posting the Block activity. The server SHOULD prevent the blocked user from interacting with any object posted by the actor.
Servers SHOULD NOT deliver Block Activities to their object.
func CollectionManagementActivity ¶
CollectionManagementActivity processes matching activities
https://www.w3.org/TR/activitystreams-vocabulary/#h-motivations-collections
The Collection Management use case primarily deals with activities involving the management of content within collections. Examples of collections include things like folders, albums, friend lists, etc. This includes, for instance, activities such as "Sally added a file to Folder A", "John moved the file from Folder A to Folder B", etc.
func ContentExperienceActivity ¶
ContentExperienceActivity processes matching activities
https://www.w3.org/TR/activitystreams-vocabulary/#h-motivations-experience
The Content Experience use case primarily deals with describing activities involving listening to, reading, or viewing content. For instance, "Sally read the article", "Joe listened to the song".
func ContentManagementActivityFromClient ¶
ContentManagementActivityFromClient processes matching activities.
https://www.w3.org/TR/activitystreams-vocabulary/#h-motivations-crud
The Content Management use case primarily deals with activities that involve the creation, modification or deletion of content. This includes, for instance, activities such as "John created a new note", "Sally updated an article", and "Joe deleted the photo".
func CreateActivityFromClient ¶
CreateActivityFromClient
https://www.w3.org/TR/activitypub/#create-activity-outbox
The Create activity is used when posting a new object. This has the side effect that the object embedded within the Activity (in the object property) is created. When a Create activity is posted, the actor of the activity SHOULD be copied onto the object's attributedTo field. A mismatch between addressing of the Create activity and its object is likely to lead to confusion. As such, a server SHOULD copy any recipients of the Create activity to its object upon initial distribution, and likewise with copying recipients from the object to the wrapping Create activity. Note that it is acceptable for the object's addressing to be changed later without changing the Create's addressing (for example via an Update activity).
https://www.w3.org/TR/activitypub/#create-activity-inbox
Receiving a Create activity in an inbox has surprisingly few side effects; the activity should appear in the actor's inbox, and it is likely that the server will want to locally store a representation of this activity and its accompanying object. However, this mostly happens in general with processing activities delivered to an inbox anyway.
func DeleteActivity ¶
DeleteActivity
https://www.w3.org/TR/activitypub/#delete-activity-outbox
The Delete activity is used to delete an already existing object. The side effect of this is that the server MAY replace the object with a Tombstone of the object that will be displayed in activities which reference the deleted object. If the deleted object is requested the server SHOULD respond with either the HTTP 410 Gone status code if a Tombstone object is presented as the response body, otherwise respond with a HTTP 404 Not Found.
https://www.w3.org/TR/activitypub/#delete-activity-inbox
The side effect of receiving this is that (assuming the object is owned by the sending actor / server) the server receiving the delete activity SHOULD remove its representation of the object with the same id, and MAY replace that representation with a Tombstone object.
Note: that after an activity has been transmitted from an origin server to a remote server, there is nothing in the
ActivityPub protocol that can enforce remote deletion of an object's representation.
func EventRSVPActivity ¶
EventRSVPActivity processes matching activities
https://www.w3.org/TR/activitystreams-vocabulary/#h-motivations-rsvp
The Event RSVP use case primarily deals with invitations to events and RSVP type responses.
func FilterItem ¶
func FlagActivity ¶
FlagActivity There isn't any side effect to this activity except delivering it to the inboxes of its recipients. From the list of recipients we remove the Object itself if it represents an Actor being flagged, or its author if it's another type of object.
func FollowActivity ¶
FollowActivity is used when following an actor.
https://www.w3.org/TR/activitypub/#follow-activity-outbox
The Follow activity is used to subscribe to the activities of another actor. The side effect of receiving this in an outbox is that the server SHOULD add the object to the actor's following Collection when and only if an Accept activity is subsequently received with this Follow activity as its object.
https://www.w3.org/TR/activitypub/#follow-activity-inbox
The side effect of receiving this in an inbox is that the server SHOULD generate either an Accept or Reject activity with the Follow as the object and deliver it to the actor of the Follow. The Accept or Reject MAY be generated automatically, or MAY be the result of user input (possibly after some delay in which the user reviews). Servers MAY choose to not explicitly send a Reject in response to a Follow, though implementors ought to be aware that the server sending the request could be left in an intermediate state. For example, a server might not send a Reject to protect a user's privacy. In the case of receiving an "Accept" referencing this Follow as the object, the server SHOULD add the actor to the object actor's Followers Collection. In the case of a Reject, the server MUST NOT add the actor to the object actor's Followers Collection.
NOTE: Sometimes a successful Follow subscription may occur but at some future point delivery to the follower fails for an extended period of time. Implementations should be aware that there is no guarantee that actors on the network will remain reachable and should implement accordingly. For instance, if attempting to deliver to an actor for perhaps six months while the follower remains unreachable, it is reasonable that the delivering server remove the subscriber from the followers list. Timeframes and behavior for dealing with unreachable actors are left to the discretion of the delivering server.
func GeoSocialEventsActivity ¶
GeoSocialEventsActivity processes matching activities
https://www.w3.org/TR/activitystreams-vocabulary/#h-motivations-geo
The Geo-Social Events use case primarily deals with activities involving geo-tagging type activities. For instance, it can include activities such as "Joe arrived at work", "Sally left work", and "John is travel from home to work".
func GeoSocialEventsIntransitiveActivity ¶
func GeoSocialEventsIntransitiveActivity(l WriteStore, act *vocab.IntransitiveActivity) (*vocab.IntransitiveActivity, error)
GeoSocialEventsIntransitiveActivity processes matching activities
https://www.w3.org/TR/activitystreams-vocabulary/#h-motivations-geo
The Geo-Social Events use case primarily deals with activities involving geo-tagging type activities. For instance, it can include activities such as "Joe arrived at work", "Sally left work", and "John is travel from home to work".
func GroupManagementActivity ¶
GroupManagementActivity processes matching activities
https://www.w3.org/TR/activitystreams-vocabulary/#h-motivations-group
The Group Management use case primarily deals with management of groups. It can include, for instance, activities such as "John added Sally to Group A", "Sally joined Group A", "Joe left Group A", etc.
func IRIBelongsToActor ¶
IRIBelongsToActor checks if the search iri represents any of the collections associated with the actor.
func IgnoreActivity ¶
IgnoreActivity This relies on custom behavior for the repository, which would allow for an ignored collection, where we save these
func NegatingActivity ¶
NegatingActivity processes matching activities
https://www.w3.org/TR/activitystreams-vocabulary/#h-motivations-undo
The Negating Activity use case primarily deals with the ability to redact previously completed activities. See 5.5 Inverse Activities and "Undo" for more information: https://www.w3.org/TR/activitystreams-vocabulary/#inverse
func NotificationActivity ¶
NotificationActivity processes matching activities
https://www.w3.org/TR/activitystreams-vocabulary/#h-motivations-notification
The Notification use case primarily deals with calling attention to particular objects or notifications.
func OffersActivity ¶
OffersActivity processes matching activities
https://www.w3.org/TR/activitystreams-vocabulary/#h-motivations-offer
The Offers use case deals with activities involving offering one object to another. It can include, for instance, activities such as "Company A is offering a discount on purchase of Product Z to Sally", "Sally is offering to add a File to Folder A", etc.
func QuestionActivity ¶
QuestionActivity processes matching activities
https://www.w3.org/TR/activitystreams-vocabulary/#h-motivations-questions
The Questions use case primarily deals with representing inquiries of any type. See 5.4 Representing Questions for more information: https://www.w3.org/TR/activitystreams-vocabulary/#questions
func ReactionsActivity ¶
ReactionsActivity processes matching activities
https://www.w3.org/TR/activitystreams-vocabulary/#h-motivations-respond
The Reactions use case primarily deals with reactions to content. This can include activities such as liking or disliking content, ignoring updates, flagging content as being inappropriate, accepting or rejecting objects, etc.
func RejectActivity ¶
func RelationshipManagementActivity ¶
func RelationshipManagementActivity(p P, act *vocab.Activity, receivedIn vocab.IRI) (*vocab.Activity, error)
RelationshipManagementActivity processes matching activities
https://www.w3.org/TR/activitystreams-vocabulary/#h-motivations-relationships
The Relationship Management use case primarily deals with representing activities involving the management of interpersonal and social relationships (e.g. friend requests, management of social network, etc). See 5.2 Representing Relationships Between Entities for more information: https://www.w3.org/TR/activitystreams-vocabulary/#connections
func SetIDIfMissing ¶
func UndoActivity ¶
UndoActivity
https://www.w3.org/TR/activitypub/#undo-activity-outbox
The Undo activity is used to undo a previous activity. See the Activity Vocabulary documentation on Inverse Activities and "Undo". For example, Undo may be used to undo a previous Like, Follow, or Block. The undo activity and the activity being undone MUST both have the same actor. Side effects should be undone, to the extent possible. For example, if undoing a Like, any counter that had been incremented previously should be decremented appropriately. There are some exceptions where there is an existing and explicit "inverse activity" which should be used instead. Create based activities should instead use Delete, and Add activities should use Remove.
https://www.w3.org/TR/activitypub/#undo-activity-inbox
The Undo activity is used to undo the side effects of previous activities. See the ActivityStreams documentation on Inverse Activities and "Undo". The scope and restrictions of the Undo activity are the same as for the Undo activity in the context of client to server interactions, but applied to a federated context.
func UndoAppreciationActivity ¶
UndoAppreciationActivity
Removes the side effects of an existing Appreciation activity (Like or Dislike) Currently this means only removal of the Liked/Disliked object from the actor's `liked` collection and removal of the Like/Dislike Activity from the object's `likes` collection
func UndoRelationshipManagementActivity ¶
UndoRelationshipManagementActivity
Removes the side effects of an existing RelationshipActivity activity (Follow, Block, Ignore, Flag) Currently this means the removal of the objet from the collection corresponding to the original Activity type. Follow - removes the original object from the actor's followers collection. Block - removes the original object from the actor's blocked collection. Ignore - removes the original object from the actor's ignored collection. Flag - is a special case where there isn't a specific collection that needs to be operated on.
func UpdateActivity ¶
UpdateActivity
https://www.w3.org/TR/activitypub/#update-activity-outbox
The Update activity is used when updating an already existing object. The side effect of this is that the object MUST be modified to reflect the new structure as defined in the update activity, assuming the actor has permission to update this object.
https://www.w3.org/TR/activitypub/#update-activity-inbox
For server to server interactions, an Update activity means that the receiving server SHOULD update its copy of the object of the same id to the copy supplied in the Update activity. Unlike the client to server handling of the Update activity, this is not a partial update but a complete replacement of the object. The receiving server MUST take care to be sure that the Update is authorized to modify its object. At minimum, this may be done by ensuring that the Update and its object are of same origin.
func ValidateClientCollectionManagementActivity ¶
ValidateClientCollectionManagementActivity
func ValidateClientContentExperienceActivity ¶
ValidateClientContentExperienceActivity
func ValidateClientContentManagementActivity ¶
ValidateClientContentManagementActivity
func ValidateClientEventRSVPActivity ¶
ValidateClientEventRSVPActivity
func ValidateClientGeoSocialEventsActivity ¶
ValidateClientGeoSocialEventsActivity
func ValidateClientGroupManagementActivity ¶
ValidateClientGroupManagementActivity
func ValidateClientNegatingActivity ¶
ValidateClientNegatingActivity
func ValidateClientNotificationActivity ¶
ValidateClientNotificationActivity
func ValidateClientOffersActivity ¶
ValidateClientOffersActivity
func ValidateClientQuestionActivity ¶
ValidateClientQuestionActivity
func ValidateClientReactionsActivity ¶
ValidateClientReactionsActivity
Types ¶
type ActivityHandlerFn ¶
ActivityHandlerFn is the type that we're using to represent handlers that process requests containing an ActivityStreams Activity. It needs to implement the http.Handler interface.
It is considered that following the execution of the handler, we return a pair formed of an HTTP status together with an IRI representing a new Object - in the case of transitive activities that had a side effect, or an error. In the case of intransitive activities the iri will always be empty.
func (ActivityHandlerFn) ServeHTTP ¶
func (a ActivityHandlerFn) ServeHTTP(w http.ResponseWriter, r *http.Request)
ServeHTTP implements the http.Handler interface for the ActivityHandlerFn type
func (ActivityHandlerFn) ValidMethod ¶
func (a ActivityHandlerFn) ValidMethod(r *http.Request) bool
ValidMethod validates if the current handler can process the current request
func (ActivityHandlerFn) ValidateRequest ¶
func (a ActivityHandlerFn) ValidateRequest(r *http.Request) (int, error)
ValidateRequest validates if the current handler can process the current request
type ActivityValidator ¶
type ActivityValidator interface { ClientActivityValidator ServerActivityValidator }
ActivityValidator is an interface used for validating activity objects.
type ActorValidator ¶
ActorValidator is an interface used for validating actor objects
type C2SProcessor ¶
C2SProcessor
type ClientActivityValidator ¶
type CollectionHandlerFn ¶
type CollectionHandlerFn func(vocab.CollectionPath, *http.Request) (vocab.CollectionInterface, error)
CollectionHandlerFn is the type that we're using to represent handlers that will return ActivityStreams Collection or OrderedCollection objects. It needs to implement the http.Handler interface.
func (CollectionHandlerFn) ServeHTTP ¶
func (c CollectionHandlerFn) ServeHTTP(w http.ResponseWriter, r *http.Request)
ServeHTTP implements the http.Handler interface for the CollectionHandlerFn type
func (CollectionHandlerFn) ValidMethod ¶
func (c CollectionHandlerFn) ValidMethod(r *http.Request) bool
ValidMethod validates if the current handler can process the current request
func (CollectionHandlerFn) ValidateRequest ¶
func (c CollectionHandlerFn) ValidateRequest(r *http.Request) (int, error)
ValidateRequest validates if the current handler can process the current request
type CollectionStore ¶
type CollectionStore interface { // Create creates the "col" collection. Create(col vocab.CollectionInterface) (vocab.CollectionInterface, error) // AddTo adds "it" element to the "col" collection. AddTo(col vocab.IRI, it vocab.Item) error // RemoveFrom removes "it" item from "col" collection RemoveFrom(col vocab.IRI, it vocab.Item) error }
CollectionStore allows operations on ActivityStreams collections
type CollectionTyper ¶
type CollectionTyper interface {
Type(r *http.Request) vocab.CollectionPath
}
CollectionTyper allows external packages to tell us which CollectionPath the current HTTP request addresses
var Typer CollectionTyper = pathTyper{}
Typer is the static package variable that determines a CollectionPath type for a particular request It can be overloaded from outside packages. @TODO(marius): This should be moved as a property on an instantiable package object, instead of keeping it here
type Filterable ¶
Filterable can filter objects by Type and ID This should be the minimal interface a filter object should implement for the storage layer to work. It also allows for an activitypub.IRI to be used as a filter.
type FilterableActivity ¶
type FilterableActivity interface { FilterableObject Actors() vocab.IRIs Objects() vocab.IRIs Targets() vocab.IRIs }
FilterableActivity can filter activities
type FilterableCollection ¶
type FilterableCollection interface { FilterableObject TotalItemsGt() uint TotalItemsLt() uint TotalItemsEq() uint TotalItemsGtE() uint TotalItemsLtE() uint Contains() vocab.IRIs }
FilterableCollection can filter collections
type FilterableItems ¶
type FilterableItems interface { Filterable Types() vocab.ActivityVocabularyTypes IRIs() vocab.IRIs }
type FilterableObject ¶
type FilterableObject interface { FilterableItems AttributedTo() vocab.IRIs InReplyTo() vocab.IRIs MediaTypes() []vocab.MimeType Names() []string Content() []string //PublishedBefore() time.Time //PublishedAfter() time.Time URLs() vocab.IRIs // Audience returns the list of IRIs to check against full Audience targeting for the object // It should include all relevant fields: To, CC, BTo, BCC, and Audience // --- // An element of the Audience is used to get its Inbox end-point and then disseminate the current Activity // to it. Audience() vocab.IRIs // Context returns the list of IRIs to check against an Object's Context property. Context() vocab.IRIs // Generator returns the list of IRIs to check against an Object's Generator property. Generator() vocab.IRIs }
FilterableObject can filter objects
type IDGenerator ¶
type IDGenerator func(it vocab.Item, receivedIn vocab.Item, byActivity vocab.Item) (vocab.ID, error)
IDGenerator takes an ActivityStreams object, a collection to store it in, and the activity that has it as object:
"it" is the object we want to generate the ID for. "partOf" represents the IRI of the Collection that it is a part of. "by" represents the Activity that generated the object
type IRIValidator ¶
IRIValidator designates the type for a function that can validate an IRI It's currently used as the type for var isLocalIRI
type ItemHandlerFn ¶
ItemHandlerFn is the type that we're using to represent handlers that return ActivityStreams objects. It needs to implement the http.Handler interface
func (ItemHandlerFn) ServeHTTP ¶
func (i ItemHandlerFn) ServeHTTP(w http.ResponseWriter, r *http.Request)
ServeHTTP implements the http.Handler interface for the ItemHandlerFn type
func (ItemHandlerFn) ValidMethod ¶
func (i ItemHandlerFn) ValidMethod(r *http.Request) bool
ValidMethod validates if the current handler can process the current request
func (ItemHandlerFn) ValidateRequest ¶
func (i ItemHandlerFn) ValidateRequest(r *http.Request) (int, error)
ValidateRequest validates if the current handler can process the current request
type MethodValidator ¶
MethodValidator is the interface need to be implemented to specify if an HTTP request's method is supported by the implementor object
type ObjectValidator ¶
ObjectValidator is an interface used for validating generic objects
type OptionFn ¶
type OptionFn func(s *P)
func WithActorKeyGenerator ¶
func WithActorKeyGenerator(genFn vocab.WithActorFn) OptionFn
func WithClient ¶
func WithIDGenerator ¶
func WithIDGenerator(genFn IDGenerator) OptionFn
func WithLocalIRIChecker ¶
func WithLocalIRIChecker(isLocalFn IRIValidator) OptionFn
func WithLogger ¶
func WithStorage ¶
type P ¶
type P struct {
// contains filtered or unexported fields
}
func (P) AddItemToCollection ¶
AddItemToCollection attempts to append "it" to collection "col"
If the collection is not local, it doesn't do anything If the item is a non-local IRI, it tries to dereference it, and then save a local representation of it.
func (P) AddToLocalCollections ¶
AddToLocalCollections handles the dissemination of the received it Activity to the local collections, it is addressed to:
- the author's Outbox
- the recipients' Inboxes
func (P) AddToRemoteCollections ¶
AddToRemoteCollections handles the dissemination of the received it Activity to the local collections, it is addressed to:
- the recipients' Inboxes
func (P) BuildInboxRecipientsList ¶
func (p P) BuildInboxRecipientsList(it vocab.Item, receivedIn vocab.IRI) (vocab.ItemCollection, error)
BuildInboxRecipientsList builds the recipients list of the received 'it' Activity is addressed to:
- the author's Outbox
- the recipients' Inboxes
func (P) BuildOutboxRecipientsList ¶
func (p P) BuildOutboxRecipientsList(it vocab.Item, receivedIn vocab.IRI) (vocab.ItemCollection, error)
BuildOutboxRecipientsList builds the recipients list of the received 'it' Activity is addressed to:
- the author's Outbox
- the recipients' Inboxes
func (P) BuildReplyToCollections ¶
BuildReplyToCollections builds the list of objects that it is inReplyTo
func (P) CreateCollectionsForObject ¶
CreateCollectionsForObject creates the objects corresponding to each collection that an Actor has set.
func (P) IsLocalIRI ¶
IsLocalIRI shows if the received IRI belongs to the current instance
func (P) ProcessActivity ¶
func (p P) ProcessActivity(it vocab.Item, author vocab.Actor, receivedIn vocab.IRI) (vocab.Item, error)
ProcessActivity processes an Activity received
func (P) ProcessClientActivity ¶
func (p P) ProcessClientActivity(it vocab.Item, author vocab.Actor, receivedIn vocab.IRI) (vocab.Item, error)
ProcessClientActivity processes an Activity received in a client to server request
https://www.w3.org/TR/activitypub/#client-to-server-interactions
Activities as defined by [ActivityStreams] are the core mechanism for creating, modifying and sharing content within the social graph.
Client to server interaction takes place through clients posting Activities to an actor's outbox. To do this, clients MUST discover the URL of the actor's outbox from their profile and then MUST make an HTTP POST request to this URL with the Content-Type of 'application/ld+json; profile="https://www.w3.org/ns/activitystreams"'. Servers MAY interpret a Content-Type or Accept header of application/activity+json as equivalent to 'application/ld+json; profile="https://www.w3.org/ns/activitystreams"' for client-to-server interactions. The request MUST be authenticated with the credentials of the user to whom the outbox belongs. The body of the POST request MUST contain a single Activity (which MAY contain embedded objects), or a single non-Activity object which will be wrapped in a Create activity by the server.
If an Activity is submitted with a value in the id property, servers MUST ignore this and generate a new id for the Activity. Servers MUST return a 201 Created HTTP code, and unless the activity is transient, MUST include the new id in the Location header.
The server MUST remove the bto and/or bcc properties, if they exist, from the ActivityStreams object before delivery, but MUST utilize the addressing originally stored on the bto / bcc properties for determining recipients in delivery.
The server MUST then add this new Activity to the outbox collection. Depending on the type of Activity, servers may then be required to carry out further side effects. (However, there is no guarantee that time the Activity may appear in the outbox. The Activity might appear after a delay or disappear at any period). These are described per individual Activity below.
Attempts to submit objects to servers not implementing client to server support SHOULD result in a 405 Method Not Allowed response.
HTTP caching mechanisms [RFC7234] SHOULD be respected when appropriate, both in clients receiving responses from servers as well as servers sending responses to clients.
func (P) ProcessOutboxDelivery ¶
ProcessOutboxDelivery
Outbox Delivery Requirements for Server to Server ¶
https://www.w3.org/TR/activitypub/#outbox-delivery
When objects are received in the outbox (for servers which support both Client to Server interactions and Server to Server Interactions), the server MUST target and deliver to:
The to, bto, cc, bcc or audience fields if their values are individuals or Collections owned by the actor. These fields will have been populated appropriately by the client which posted the Activity to the outbox.
Additional recommendation from the ActivityPub mailing list: Activities addressed to `Public` usually appear only in the inboxes of actors that follow the activity's `actor` property.
func (P) ProcessServerActivity ¶
func (p P) ProcessServerActivity(it vocab.Item, author vocab.Actor, receivedIn vocab.IRI) (vocab.Item, error)
ProcessServerActivity processes an Activity received in a server to server request
https://www.w3.org/TR/activitypub/#server-to-server-interactions
Servers communicate with other servers and propagate information across the social graph by posting activities to actors' inbox endpoints. An Activity sent over the network SHOULD have an id, unless it is intended to be transient (in which case it MAY omit the id).
POST requests (eg. to the inbox) MUST be made with a Content-Type of 'application/ld+json; profile="https://www.w3.org/ns/activitystreams"' and GET requests (see also 3.2 Retrieving objects) with an Accept header of 'application/ld+json; profile="https://www.w3.org/ns/activitystreams"'. Servers SHOULD interpret a Content-Type or Accept header of 'application/activity+json' as equivalent to application/ld+json; profile="https://www.w3.org/ns/activitystreams" for server-to-server interactions.
In order to propagate updates throughout the social graph, Activities are sent to the appropriate recipients. First, these recipients are determined through following the appropriate links between objects until you reach an actor, and then the Activity is inserted into the actor's inbox (delivery). This allows recipient servers to:
conduct any side effects related to the Activity (for example, notification that an actor has liked an object is used to update the object's like count); deliver the Activity to recipients of the original object, to ensure updates are propagated to the whole social graph (see inbox delivery).
Delivery is usually triggered by one of:
* an Activity being created in an actor's outbox with their Followers Collection as the recipient. * an Activity being created in an actor's outbox with directly addressed recipients. * an Activity being created in an actor's outbox with user-curated collections as recipients. * an Activity being created in an actor's outbox or inbox which references another object.
Servers performing delivery to the inbox or sharedInbox properties of actors on other servers MUST provide the object property in the activity: Create, Update, Delete, Follow, Add, Remove, Like, Block, Undo. Additionally, servers performing server to server delivery of the following activities MUST also provide the target property: Add, Remove.
HTTP caching mechanisms [RFC7234] SHOULD be respected when appropriate, both when receiving responses from other servers and when sending responses to other servers.
func (P) ProcessServerInboxDelivery ¶
ProcessServerInboxDelivery processes an incoming activity received in an actor's Inbox collection
Forwarding from Inbox ¶
https://www.w3.org/TR/activitypub/#inbox-forwarding
NOTE: Forwarding to avoid the ghost replies problem The following section is to mitigate the "ghost replies" problem which occasionally causes problems on federated networks. This problem is best demonstrated with an example.
Alyssa makes a post about her having successfully presented a paper at a conference and sends it to her followers collection, which includes her friend Ben. Ben replies to Alyssa's message congratulating her and includes her followers collection on the recipients. However, Ben has no access to see the members of Alyssa's followers collection, so his server does not forward his messages to their inbox. Without the following mechanism, if Alyssa were then to reply to Ben, her followers would see Alyssa replying to Ben without having ever seen Ben interacting. This would be very confusing!
When Activities are received in the inbox, the server needs to forward these to recipients that the origin was unable to deliver them to. To do this, the server MUST target and deliver to the values of to, cc, and/or audience if and only if all of the following are true:
* This is the first time the server has seen this Activity. * The values of to, cc, and/or audience contain a Collection owned by the server. * The values of inReplyTo, object, target and/or tag are objects owned by the server. * The server SHOULD recurse through these values to look for linked objects owned by the server, and SHOULD set a maximum limit for recursion (ie. the point at which the thread is so deep the recipients followers may not mind if they are no longer getting updates that don't directly involve the recipient). The server MUST only target the values of to, cc, and/or audience on the original object being forwarded, and not pick up any new addressees whilst recursing through the linked objects (in case these addressees were purposefully amended by or via the client).
The server MAY filter its delivery targets according to implementation-specific rules (for example, spam filtering).
func (P) ValidateActivity ¶
func (P) ValidateActor ¶
func (P) ValidateAudience ¶
func (p P) ValidateAudience(audience ...vocab.ItemCollection) error
func (P) ValidateClientActivity ¶
func (P) ValidateClientActor ¶
func (P) ValidateServerActivity ¶
func (P) ValidateServerActor ¶
type RequestValidator ¶
RequestValidator is the interface need to be implemented to specify if the whole HTTP request is valid in the context of the implementor object
type S2SProcessor ¶
type ServerActivityValidator ¶
type Store ¶
type Store interface { ReadStore WriteStore CollectionStore }
type WriteStore ¶
type WriteStore interface { // Save saves the incoming ActivityStreams Object, and returns it together with any properties // populated by the method's side effects. (eg, Published property can point to the current time, etc.). Save(vocab.Item) (vocab.Item, error) // Delete deletes completely from storage the ActivityStreams Object Delete(vocab.Item) error }
WriteStore saves ActivityStreams objects.