Add ClearDBData functionality for analysis and repository components

- Introduced `ClearDBData` methods in `Analysis`, `Alert`, and `BruteForceProtection` components.
- Implemented `Clear` operations for `AlertGroupRepository` and `BruteForceProtectionGroupRepository` to reset database buckets.
- Updated `Analyzer` to invoke `ClearDBData` for cleanup logic.

internal/daemon/analyzer/analyzer.go

@@ -14,6 +14,7 @@ import (
 
 type Analyzer interface {
 	Run(ctx context.Context)
+	ClearDBData() error
 	Close() error
 }
 
@@ -86,6 +87,21 @@ func (a *analyzer) Run(ctx context.Context) {
 	a.logger.Debug("Analyzer is start")
 }
 
+func (a *analyzer) ClearDBData() error {
+	a.logger.Debug("Clear data")
+
+	clearDBErrors, err := a.analysis.ClearDBData()
+	if err != nil {
+		for _, err := range clearDBErrors {
+			a.logger.Error(err.Error())
+		}
+
+		return err
+	}
+
+	return nil
+}
+
 func (a *analyzer) processLogs(ctx context.Context) {
 	for {
 		select {

internal/daemon/analyzer/log/analysis.go

@@ -1,6 +1,8 @@
 package log
 
 import (
+	"fmt"
+
 	analysisServices "git.kor-elf.net/kor-elf-shield/kor-elf-shield/internal/daemon/analyzer/log/analysis"
 	"git.kor-elf.net/kor-elf-shield/kor-elf-shield/internal/daemon/analyzer/log/analysis/alert_group"
 	"git.kor-elf.net/kor-elf-shield/kor-elf-shield/internal/daemon/analyzer/log/analysis/brute_force_protection_group"
@@ -12,6 +14,7 @@ import (
 type Analysis interface {
 	Alert(entry *analysisServices.Entry)
 	BruteForceProtection(entry *analysisServices.Entry)
+	ClearDBData() ([]error, error)
 }
 
 type analysis struct {
@@ -36,3 +39,19 @@ func (a *analysis) Alert(entry *analysisServices.Entry) {
 func (a *analysis) BruteForceProtection(entry *analysisServices.Entry) {
 	a.bruteForceProtectionService.Analyze(entry)
 }
+
+func (a *analysis) ClearDBData() ([]error, error) {
+	var errClearDB []error
+	if err := a.alertService.ClearDBData(); err != nil {
+		errClearDB = append(errClearDB, err)
+	}
+	if err := a.bruteForceProtectionService.ClearDBData(); err != nil {
+		errClearDB = append(errClearDB, err)
+	}
+
+	if len(errClearDB) > 0 {
+		return nil, fmt.Errorf("failed to clear database data: %v", errClearDB)
+	}
+
+	return errClearDB, nil
+}

internal/daemon/analyzer/log/analysis/alert.go

@@ -13,6 +13,7 @@ import (
 
 type Alert interface {
 	Analyze(entry *Entry)
+	ClearDBData() error
 }
 
 type alert struct {
@@ -82,6 +83,10 @@ func (a *alert) Analyze(entry *Entry) {
 	}
 }
 
+func (a *alert) ClearDBData() error {
+	return a.alertGroupService.ClearDBData()
+}
+
 func (a *alert) analyzeRule(rule *config.AlertRule, message string) alertAnalyzeRuleReturn {
 	result := alertAnalyzeRuleReturn{
 		found:  false,

internal/daemon/analyzer/log/analysis/brute_force_protection.go

@@ -15,6 +15,7 @@ import (
 
 type BruteForceProtection interface {
 	Analyze(entry *Entry)
+	ClearDBData() error
 }
 
 type BlockIPFunc func(blockIP blocking.BlockIP) error
@@ -106,6 +107,10 @@ func (p *bruteForceProtection) Analyze(entry *Entry) {
 	}
 }
 
+func (p *bruteForceProtection) ClearDBData() error {
+	return p.groupService.ClearDBData()
+}
+
 func (p *bruteForceProtection) analyzeRule(rule *brute_force_protection.Rule, message string) bruteForceProtectionAnalyzeRuleReturn {
 	result := bruteForceProtectionAnalyzeRuleReturn{
 		found:  false,

internal/daemon/db/repository/alert_group.go

@@ -2,14 +2,17 @@ package repository
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 
 	"git.kor-elf.net/kor-elf-shield/kor-elf-shield/internal/daemon/db/entity"
 	"go.etcd.io/bbolt"
+	bboltErrors "go.etcd.io/bbolt/errors"
 )
 
 type AlertGroupRepository interface {
 	Update(name string, f func(*entity.AlertGroup) (*entity.AlertGroup, error)) error
+	Clear() error
 }
 
 type alertGroupRepository struct {
@@ -55,3 +58,15 @@ func (r *alertGroupRepository) Update(name string, f func(*entity.AlertGroup) (*
 		return b.Put(key, data)
 	})
 }
+
+func (r *alertGroupRepository) Clear() error {
+	return r.db.Update(func(tx *bbolt.Tx) error {
+		err := tx.DeleteBucket([]byte(r.bucket))
+		if errors.Is(err, bboltErrors.ErrBucketNotFound) {
+			// If the bucket may not exist, ignore ErrBucketNotFound
+			return nil
+		}
+		_, err = tx.CreateBucketIfNotExists([]byte(r.bucket))
+		return err
+	})
+}

internal/daemon/db/repository/brute_force_protection_group.go

@@ -2,15 +2,18 @@ package repository
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net"
 
 	"git.kor-elf.net/kor-elf-shield/kor-elf-shield/internal/daemon/db/entity"
 	"go.etcd.io/bbolt"
+	bboltErrors "go.etcd.io/bbolt/errors"
 )
 
 type BruteForceProtectionGroupRepository interface {
 	Update(name string, ip net.IP, f func(*entity.BruteForceProtectionGroup) (*entity.BruteForceProtectionGroup, error)) error
+	Clear() error
 }
 
 type bruteForceProtectionGroupRepository struct {
@@ -60,6 +63,18 @@ func (r *bruteForceProtectionGroupRepository) Update(name string, ip net.IP, f f
 	})
 }
 
+func (r *bruteForceProtectionGroupRepository) Clear() error {
+	return r.db.Update(func(tx *bbolt.Tx) error {
+		err := tx.DeleteBucket([]byte(r.bucket))
+		if errors.Is(err, bboltErrors.ErrBucketNotFound) {
+			// If the bucket may not exist, ignore ErrBucketNotFound
+			return nil
+		}
+		_, err = tx.CreateBucketIfNotExists([]byte(r.bucket))
+		return err
+	})
+}
+
 func keyGroupIP(groupID string, ip net.IP) ([]byte, error) {
 	if ip == nil {
 		return nil, fmt.Errorf("ip cannot be nil")