✨ Add appeal count reset

automod/countstore/countstore.go

@@ -48,6 +48,7 @@ type CountStore interface {
 	// TODO: batch increment method
 	GetCountDistinct(ctx context.Context, name, bucket, period string) (int, error)
 	IncrementDistinct(ctx context.Context, name, bucket, val string) error
+	Reset(ctx context.Context, name, val string) error
 }
 
 func periodBucket(name, val, period string) string {

automod/countstore/countstore_mem.go

@@ -40,6 +40,12 @@ func (s MemCountStore) Increment(ctx context.Context, name, val string) error {
 	return nil
 }
 
+func (s *MemCountStore) Reset(ctx context.Context, name, val string) error {
+	key := periodBucket(name, val, PeriodTotal)
+	s.Counts.Delete(key)
+	return nil
+}
+
 func (s MemCountStore) IncrementPeriod(ctx context.Context, name, val, period string) error {
 	k := periodBucket(name, val, period)
 	s.Counts.Compute(k, func(oldVal int, _ bool) (int, bool) {

automod/countstore/countstore_redis.go

@@ -66,6 +66,17 @@ func (s *RedisCountStore) Increment(ctx context.Context, name, val string) error
 	return err
 }
 
+func (s *RedisCountStore) Reset(ctx context.Context, name, val string) error {
+	var key string
+
+	// increment multiple counters in a single redis round-trip
+	multi := s.Client.Pipeline()
+	key = redisCountPrefix + periodBucket(name, val, PeriodHour)
+	multi.Del(ctx, key)
+	_, err := multi.Exec(ctx)
+	return err
+}
+
 // Variant of Increment() which only acts on a single specified time period. The intended us of this variant is to control the total number of counters persisted, by using a relatively short time period, for which the counters will expire.
 func (s *RedisCountStore) IncrementPeriod(ctx context.Context, name, val, period string) error {
 

automod/engine/context.go

@@ -243,6 +243,9 @@ func (c *BaseContext) GetAccountMeta(did syntax.DID) *AccountMeta {
 func (c *BaseContext) Increment(name, val string) {
 	c.effects.Increment(name, val)
 }
+func (c *BaseContext) ResetCounter(name, val string) {
+	c.effects.ResetCounter(name, val)
+}
 
 func (c *BaseContext) IncrementDistinct(name, bucket, val string) {
 	c.effects.IncrementDistinct(name, bucket, val)

automod/engine/effects.go

@@ -36,6 +36,8 @@ type Effects struct {
 	mu sync.Mutex
 	// List of counters which should be incremented as part of processing this event. These are collected during rule execution and persisted in bulk at the end.
 	CounterIncrements []CounterRef
+	// List of counters which should be reset as part of processing this event. These are collected during rule execution and persisted in bulk at the end.
+	CounterResets []CounterRef
 	// Similar to "CounterIncrements", but for "distinct" style counters
 	CounterDistinctIncrements []CounterDistinctRef // TODO: better variable names
 	// Label values which should be applied to the overall account, as a result of rule execution.
@@ -76,6 +78,16 @@ func (e *Effects) Increment(name, val string) {
 	e.CounterIncrements = append(e.CounterIncrements, CounterRef{Name: name, Val: val})
 }
 
+// Enqueues the named counter to be reset at the end of all rule processing.
+//
+// "name" is the counter namespace.
+// "val" is the specific counter with that namespace.
+func (e *Effects) ResetCounter(name, val string) {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	e.CounterResets = append(e.CounterResets, CounterRef{Name: name, Val: val})
+}
+
 // Enqueues the named counter to be incremented at the end of all rule processing. Will only increment the indicated time period bucket.
 func (e *Effects) IncrementPeriod(name, val string, period string) {
 	e.mu.Lock()

automod/engine/persist.go

@@ -29,6 +29,12 @@ func (eng *Engine) persistCounters(ctx context.Context, eff *Effects) error {
 			return err
 		}
 	}
+	for _, ref := range eff.CounterResets {
+		err := eng.Counters.Reset(ctx, ref.Name, ref.Val)
+		if err != nil {
+			return err
+		}
+	}
 	return nil
 }
 

automod/rules/resolve_appeal_on_delete.go

@@ -50,10 +50,9 @@ func MarkAppealOzoneEventRule(c *automod.OzoneEventContext) error {
 	}
 
 	if isAppealEvent {
-		c.Increment("appealed", counterKey)
+		c.Increment("appeal", counterKey)
 	} else {
-		// @TODO: We should reset the appeal counter here but there doesn't seem to be an api for it
-		// c.Reset("appealed", counterKey)
+		c.ResetCounter("appeal", counterKey)
 	}
 
 	return nil