remove push-notification support from automod engine (never used)

The idea was to integrate the automod framework with other services
which do push notifications. This never happened, and this code is
dead/untested, so removing for now.

This kind of functionality might be useful (we have lots of interaction
spam!) and could be pulled back in from git history if we ever need it.

automod/engine/context.go

···
 	Event toolsozone.ModerationDefs_ModEventView_Event
 }
 
-// Originally intended for push notifications, but can also work for any inter-account notification.
-type NotificationContext struct {
-	AccountContext
-
-	Recipient    AccountMeta
-	Notification NotificationMeta
-}
-
-// Additional notification metadata, with fields aligning with the `app.bsky.notification.listNotifications` Lexicon schemas
-type NotificationMeta struct {
-	// Expected values are 'like', 'repost', 'follow', 'mention', 'reply', and 'quote'; arbitrary values may be added in the future.
-	Reason string
-	// The content (atproto record) which was the cause of this notification. Could be a post with a mention, or a like, follow, or repost record.
-	Subject syntax.ATURI
-}
-
 // Checks that op has expected fields, based on the action type
 func (op *RecordOp) Validate() error {
 	switch op.Action {
···
 	}
 }
 
-func NewNotificationContext(ctx context.Context, eng *Engine, sender, recipient AccountMeta, reason string, subject syntax.ATURI) NotificationContext {
-	ac := NewAccountContext(ctx, eng, sender)
-	ac.BaseContext.Logger = ac.BaseContext.Logger.With("recipient", recipient.Identity.DID, "reason", reason, "subject", subject.String())
-	return NotificationContext{
-		AccountContext: ac,
-		Recipient:      recipient,
-		Notification: NotificationMeta{
-			Reason:  reason,
-			Subject: subject,
-		},
-	}
-}
-
 // fetch relationship metadata between this account and another account
 func (c *AccountContext) GetAccountRelationship(other syntax.DID) AccountRelationship {
 	rel, err := c.engine.GetAccountRelationship(c.Ctx, c.Account.Identity.DID, other)
···
 func (c *RecordContext) TakedownBlob(cid string) {
 	c.effects.TakedownBlob(cid)
 }
-
-func (c *NotificationContext) Reject() {
-	c.effects.Reject()
-}

automod/engine/engine.go

···
 	return nil
 }
 
-// returns a boolean indicating "block the event"
-// NOTE: this code is unused and should be removed
-func (eng *Engine) ProcessNotificationEvent(ctx context.Context, senderDID, recipientDID syntax.DID, reason string, subject syntax.ATURI) (bool, error) {
-	eventProcessCount.WithLabelValues("notif").Inc()
-	start := time.Now()
-	defer func() {
-		duration := time.Since(start)
-		eventProcessDuration.WithLabelValues("notif").Observe(duration.Seconds())
-	}()
-
-	// similar to an HTTP server, we want to recover any panics from rule execution
-	defer func() {
-		if r := recover(); r != nil {
-			eng.Logger.Error("automod event execution exception", "err", r, "sender", senderDID, "recipient", recipientDID)
-		}
-	}()
-	var cancel context.CancelFunc
-	ctx, cancel = context.WithTimeout(ctx, time.Second*5)
-	defer cancel()
-
-	senderIdent, err := eng.Directory.LookupDID(ctx, senderDID)
-	if err != nil {
-		eventErrorCount.WithLabelValues("notif").Inc()
-		return false, fmt.Errorf("resolving identity: %w", err)
-	}
-	if senderIdent == nil {
-		eventErrorCount.WithLabelValues("notif").Inc()
-		return false, fmt.Errorf("identity not found for sender DID: %s", senderDID.String())
-	}
-
-	recipientIdent, err := eng.Directory.LookupDID(ctx, recipientDID)
-	if err != nil {
-		eventErrorCount.WithLabelValues("notif").Inc()
-		return false, fmt.Errorf("resolving identity: %w", err)
-	}
-	if recipientIdent == nil {
-		eventErrorCount.WithLabelValues("notif").Inc()
-		return false, fmt.Errorf("identity not found for sender DID: %s", recipientDID.String())
-	}
-
-	senderMeta, err := eng.GetAccountMeta(ctx, senderIdent)
-	if err != nil {
-		eventErrorCount.WithLabelValues("notif").Inc()
-		return false, fmt.Errorf("failed to fetch account metadata: %w", err)
-	}
-	recipientMeta, err := eng.GetAccountMeta(ctx, recipientIdent)
-	if err != nil {
-		eventErrorCount.WithLabelValues("notif").Inc()
-		return false, fmt.Errorf("failed to fetch account metadata: %w", err)
-	}
-
-	nc := NewNotificationContext(ctx, eng, *senderMeta, *recipientMeta, reason, subject)
-	if err := eng.Rules.CallNotificationRules(&nc); err != nil {
-		eventErrorCount.WithLabelValues("notif").Inc()
-		return false, fmt.Errorf("rule execution failed: %w", err)
-	}
-	eng.CanonicalLogLineNotification(&nc)
-	return nc.effects.RejectEvent, nil
-}
-
 // Purge metadata caches for a specific account.
 func (e *Engine) PurgeAccountCaches(ctx context.Context, did syntax.DID) error {
 	e.Logger.Debug("purging account caches", "did", did.String())
···
 		"recordReports", len(c.effects.RecordReports),
 	)
 }
-
-func (e *Engine) CanonicalLogLineNotification(c *NotificationContext) {
-	c.Logger.Info("canonical-event-line",
-		"accountLabels", c.effects.AccountLabels,
-		"accountFlags", c.effects.AccountFlags,
-		"accountTags", c.effects.AccountTags,
-		"accountTakedown", c.effects.AccountTakedown,
-		"accountReports", len(c.effects.AccountReports),
-		"reject", c.effects.RejectEvent,
-	)
-}

automod/engine/ruleset.go

···
 	IdentityRules     []IdentityRuleFunc
 	AccountRules      []AccountRuleFunc
 	BlobRules         []BlobRuleFunc
-	NotificationRules []NotificationRuleFunc
 	OzoneEventRules   []OzoneEventRuleFunc
 }
 
···
 		err := f(c)
 		if err != nil {
 			c.Logger.Error("account rule execution failed", "err", err)
-		}
-	}
-	return nil
-}
-
-func (r *RuleSet) CallNotificationRules(c *NotificationContext) error {
-	for _, f := range r.NotificationRules {
-		err := f(c)
-		if err != nil {
-			c.Logger.Error("notification rule execution failed", "err", err)
 		}
 	}
 	return nil

automod/engine/ruletypes.go

···
 type PostRuleFunc = func(c *RecordContext, post *appbsky.FeedPost) error
 type ProfileRuleFunc = func(c *RecordContext, profile *appbsky.ActorProfile) error
 type BlobRuleFunc = func(c *RecordContext, blob lexutil.LexBlob, data []byte) error
-type NotificationRuleFunc = func(c *NotificationContext) error
 type OzoneEventRuleFunc = func(c *OzoneEventContext) error

automod/pkg.go

···
 type AccountContext = engine.AccountContext
 type RecordContext = engine.RecordContext
 type OzoneEventContext = engine.OzoneEventContext
-type NotificationContext = engine.NotificationContext
 type RecordOp = engine.RecordOp
 
 type IdentityRuleFunc = engine.IdentityRuleFunc
···
 type PostRuleFunc = engine.PostRuleFunc
 type ProfileRuleFunc = engine.ProfileRuleFunc
 type BlobRuleFunc = engine.BlobRuleFunc
-type NotificationRuleFunc = engine.NotificationRuleFunc
 type OzoneEventRuleFunc = engine.OzoneEventRuleFunc
 
 var (

automod/rules/all.go

···
 		BlobRules: []automod.BlobRuleFunc{
 			//BlobVerifyRule,
 		},
-		NotificationRules: []automod.NotificationRuleFunc{
-			// none
-		},
 		OzoneEventRules: []automod.OzoneEventRuleFunc{
 			HarassmentProtectionOzoneEventRule,
 		},