added maintenance cleanup for expired password reset requests

controller/maintenance.go

@@ -10,23 +10,23 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-type maintenanceAgent struct {
-	*MaintenanceConfig
+type maintenanceRegistrationAgent struct {
+	*RegistrationMaintenanceConfig
 	ctx context.Context
 }
 
-func newMaintenanceAgent(ctx context.Context, cfg *MaintenanceConfig) *maintenanceAgent {
-	return &maintenanceAgent{
-		MaintenanceConfig: cfg,
-		ctx:               ctx,
+func newRegistrationMaintenanceAgent(ctx context.Context, cfg *RegistrationMaintenanceConfig) *maintenanceRegistrationAgent {
+	return &maintenanceRegistrationAgent{
+		RegistrationMaintenanceConfig: cfg,
+		ctx:                           ctx,
 	}
 }
 
-func (ma *maintenanceAgent) run() {
-	logrus.Info("starting")
-	defer logrus.Info("stopping")
+func (ma *maintenanceRegistrationAgent) run() {
+	logrus.Infof("starting maintenance registration agent")
+	defer logrus.Info("stopping maintenance registration agent")
 
-	ticker := time.NewTicker(ma.Registration.CheckFrequency)
+	ticker := time.NewTicker(ma.CheckFrequency)
 	for {
 		select {
 		case <-ma.ctx.Done():
@@ -44,15 +44,15 @@ func (ma *maintenanceAgent) run() {
 	}
 }
 
-func (ma *maintenanceAgent) deleteExpiredAccountRequests() error {
+func (ma *maintenanceRegistrationAgent) deleteExpiredAccountRequests() error {
 	tx, err := str.Begin()
 	if err != nil {
 		return err
 	}
 	defer func() { _ = tx.Rollback() }()
 
-	timeout := time.Now().UTC().Add(-ma.Registration.ExpirationTimeout)
-	accountRequests, err := str.FindExpiredAccountRequests(timeout, ma.Registration.BatchLimit, tx)
+	timeout := time.Now().UTC().Add(-ma.ExpirationTimeout)
+	accountRequests, err := str.FindExpiredAccountRequests(timeout, ma.BatchLimit, tx)
 	if err != nil {
 		return errors.Wrapf(err, "error finding expire account requests before %v", timeout)
 	}
@@ -76,3 +76,68 @@ func (ma *maintenanceAgent) deleteExpiredAccountRequests() error {
 
 	return nil
 }
+
+type maintenanceAccountAgent struct {
+	*AccountMaintenanceConfig
+	ctx context.Context
+}
+
+func newAccountMaintenanceAgent(ctx context.Context, cfg *AccountMaintenanceConfig) *maintenanceAccountAgent {
+	return &maintenanceAccountAgent{
+		AccountMaintenanceConfig: cfg,
+		ctx:                      ctx,
+	}
+}
+
+func (ma *maintenanceAccountAgent) run() {
+	logrus.Infof("starting maintenance account agent")
+	defer logrus.Info("stopping maintenance account agent")
+
+	ticker := time.NewTicker(ma.CheckFrequency)
+	for {
+		select {
+		case <-ma.ctx.Done():
+			{
+				ticker.Stop()
+				return
+			}
+		case <-ticker.C:
+			{
+				if err := ma.deleteExpiredForgetPasswordRequests(); err != nil {
+					logrus.Error(err)
+				}
+			}
+		}
+	}
+}
+func (ma *maintenanceAccountAgent) deleteExpiredForgetPasswordRequests() error {
+	tx, err := str.Begin()
+	if err != nil {
+		return err
+	}
+	defer func() { _ = tx.Rollback() }()
+
+	timeout := time.Now().UTC().Add(-ma.ExpirationTimeout)
+	passwordResetRequests, err := str.FindExpiredPasswordResetRequests(timeout, ma.BatchLimit, tx)
+	if err != nil {
+		return errors.Wrapf(err, "error finding expired password reset requests before %v", timeout)
+	}
+	if len(passwordResetRequests) > 0 {
+		logrus.Infof("found %d expired password reset requests to remove", len(passwordResetRequests))
+		acctStrings := make([]string, len(passwordResetRequests))
+		ids := make([]int, len(passwordResetRequests))
+		for i, acct := range passwordResetRequests {
+			ids[i] = acct.Id
+			acctStrings[i] = fmt.Sprintf("{id:%d}", acct.Id)
+		}
+
+		logrus.Infof("deleting expired password reset requests: %v", strings.Join(acctStrings, ","))
+		if err := str.DeleteMultiplePasswordResetRequests(ids, tx); err != nil {
+			return errors.Wrapf(err, "error deleting expired password reset requests before %v", timeout)
+		}
+		if err := tx.Commit(); err != nil {
+			return errors.Wrapf(err, "error committing expired password reset requests deletion")
+		}
+	}
+	return nil
+}