refact: remove unused code in crowdsec-cli, apiserver, acquisition, database (#4304)

* deadcode: remove unused ip helpers in pkg/database

* deadcode: remove unused require.DB from cmd/crowdsec-cli/core

* deadcode: remove unused LogAppsecEvent() from pkg/acquisition/modules/appsec

* deadcode: remove unused createAlertsForDecisions() from pkg/apiserver

Author: mmetc

cmd/crowdsec-cli/core/require/require.go

@@ -89,14 +89,6 @@ func DBClient(ctx context.Context, dbcfg *csconfig.DatabaseCfg) (*database.Clien
 	return db, nil
 }
 
-func DB(c *csconfig.Config) error {
-	if err := c.LoadDBConfig(true); err != nil {
-		return fmt.Errorf("this command requires direct database access (must be run on the local API machine): %w", err)
-	}
-
-	return nil
-}
-
 func HubDownloader(ctx context.Context, c *csconfig.Config) (*cwhub.Downloader, error) {
 	// set branch in config, and log if necessary
 	branch, err := HubBranch(ctx, c)

pkg/acquisition/modules/appsec/utils.go

@@ -314,33 +314,6 @@ func EventFromRequest(r *appsec.ParsedRequest, labels map[string]string, txUuid
 	return evt, nil
 }
 
-func LogAppsecEvent(evt *pipeline.Event, logger *log.Entry) {
-	req := evt.Parsed["target_uri"]
-	if len(req) > 12 {
-		req = req[:10] + ".."
-	}
-
-	if evt.Meta["appsec_interrupted"] == "true" {
-		logger.WithFields(log.Fields{
-			"module":     ModuleName,
-			"source":     evt.Parsed["source_ip"],
-			"target_uri": req,
-		}).Infof("%s blocked on %s (%d rules) [%v]", evt.Parsed["source_ip"], req, len(evt.Appsec.MatchedRules), evt.Appsec.GetRuleIDs())
-	} else if evt.Parsed["outofband_interrupted"] == "true" {
-		logger.WithFields(log.Fields{
-			"module":     ModuleName,
-			"source":     evt.Parsed["source_ip"],
-			"target_uri": req,
-		}).Infof("%s out-of-band blocking rules on %s (%d rules) [%v]", evt.Parsed["source_ip"], req, len(evt.Appsec.MatchedRules), evt.Appsec.GetRuleIDs())
-	} else {
-		logger.WithFields(log.Fields{
-			"module":     ModuleName,
-			"source":     evt.Parsed["source_ip"],
-			"target_uri": req,
-		}).Debugf("%s triggered non-blocking rules on %s (%d rules) [%v]", evt.Parsed["source_ip"], req, len(evt.Appsec.MatchedRules), evt.Appsec.GetRuleIDs())
-	}
-}
-
 type ruleData struct {
 	ID           int
 	Name         string

pkg/apiserver/apic.go

@@ -471,48 +471,6 @@ func (a *apic) HandleDeletedDecisionsV3(ctx context.Context, deletedDecisions []
 	return nbDeleted, nil
 }
 
-func createAlertsForDecisions(decisions []*models.Decision) []*models.Alert {
-	newAlerts := make([]*models.Alert, 0)
-
-	for _, decision := range decisions {
-		found := false
-
-		for _, sub := range newAlerts {
-			if sub.Source.Scope == nil {
-				log.Warningf("nil scope in %+v", sub)
-				continue
-			}
-
-			if *decision.Origin == types.CAPIOrigin {
-				if *sub.Source.Scope == types.CAPIOrigin {
-					found = true
-					break
-				}
-			} else if *decision.Origin == types.ListOrigin {
-				if *sub.Source.Scope == *decision.Origin {
-					if sub.Scenario == nil {
-						log.Warningf("nil scenario in %+v", sub)
-					}
-
-					if *sub.Scenario == *decision.Scenario {
-						found = true
-						break
-					}
-				}
-			} else {
-				log.Warningf("unknown origin %s : %+v", *decision.Origin, decision)
-			}
-		}
-
-		if !found {
-			log.Debugf("Create entry for origin:%s scenario:%s", *decision.Origin, *decision.Scenario)
-			newAlerts = append(newAlerts, createAlertForDecision(decision))
-		}
-	}
-
-	return newAlerts
-}
-
 func createAlertForDecision(decision *models.Decision) *models.Alert {
 	var (
 		scenario string

pkg/apiserver/apic_test.go

@@ -362,87 +362,6 @@ func TestAPICGetMetrics(t *testing.T) {
 	}
 }
 
-func TestCreateAlertsForDecision(t *testing.T) {
-	httpBfDecisionList := &models.Decision{
-		Origin:   ptr.Of(types.ListOrigin),
-		Scenario: ptr.Of("crowdsecurity/http-bf"),
-	}
-
-	sshBfDecisionList := &models.Decision{
-		Origin:   ptr.Of(types.ListOrigin),
-		Scenario: ptr.Of("crowdsecurity/ssh-bf"),
-	}
-
-	httpBfDecisionCommunity := &models.Decision{
-		Origin:   ptr.Of(types.CAPIOrigin),
-		Scenario: ptr.Of("crowdsecurity/http-bf"),
-	}
-
-	sshBfDecisionCommunity := &models.Decision{
-		Origin:   ptr.Of(types.CAPIOrigin),
-		Scenario: ptr.Of("crowdsecurity/ssh-bf"),
-	}
-
-	type args struct {
-		decisions []*models.Decision
-	}
-
-	tests := []struct {
-		name string
-		args args
-		want []*models.Alert
-	}{
-		{
-			name: "2 decisions CAPI List Decisions should create 2 alerts",
-			args: args{
-				decisions: []*models.Decision{
-					httpBfDecisionList,
-					sshBfDecisionList,
-				},
-			},
-			want: []*models.Alert{
-				createAlertForDecision(httpBfDecisionList),
-				createAlertForDecision(sshBfDecisionList),
-			},
-		},
-		{
-			name: "2 decisions CAPI List same scenario decisions should create 1 alert",
-			args: args{
-				decisions: []*models.Decision{
-					httpBfDecisionList,
-					httpBfDecisionList,
-				},
-			},
-			want: []*models.Alert{
-				createAlertForDecision(httpBfDecisionList),
-			},
-		},
-		{
-			name: "5 decisions from community list should create 1 alert",
-			args: args{
-				decisions: []*models.Decision{
-					httpBfDecisionCommunity,
-					httpBfDecisionCommunity,
-					sshBfDecisionCommunity,
-					sshBfDecisionCommunity,
-					sshBfDecisionCommunity,
-				},
-			},
-			want: []*models.Alert{
-				createAlertForDecision(sshBfDecisionCommunity),
-			},
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := createAlertsForDecisions(tc.args.decisions); !reflect.DeepEqual(got, tc.want) {
-				t.Errorf("createAlertsForDecisions() = %v, want %v", got, tc.want)
-			}
-		})
-	}
-}
-
 func TestFillAlertsWithDecisions(t *testing.T) {
 	httpBfDecisionCommunity := &models.Decision{
 		Origin:   ptr.Of(types.CAPIOrigin),