Remove embedded tagger rules

internal/tagger/classifyJob.go

@@ -2,15 +2,16 @@
 // All rights reserved. This file is part of cc-backend.
 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file.
+
 package tagger
 
 import (
 	"bytes"
-	"embed"
 	"encoding/json"
 	"fmt"
 	"maps"
 	"os"
+	"path/filepath"
 	"strings"
 	"text/template"
 
@@ -23,8 +24,16 @@ import (
 	"github.com/expr-lang/expr/vm"
 )
 
-//go:embed jobclasses/*
-var jobClassFiles embed.FS
+const (
+	// defaultJobClassConfigPath is the default path for job classification configuration
+	defaultJobClassConfigPath = "./var/tagger/jobclasses"
+	// tagTypeJobClass is the tag type identifier for job classification tags
+	tagTypeJobClass = "jobClass"
+	// jobClassConfigDirMatch is the directory name used for matching filesystem events
+	jobClassConfigDirMatch = "jobclasses"
+	// parametersFileName is the name of the parameters configuration file
+	parametersFileName = "parameters.json"
+)
 
 // Variable defines a named expression that can be computed and reused in rules.
 // Variables are evaluated before the main rule and their results are added to the environment.
@@ -45,21 +54,21 @@ type ruleVariable struct {
 // and the final rule expression that determines if the job matches the classification.
 type RuleFormat struct {
 	// Name is a human-readable description of the rule
-	Name         string     `json:"name"`
+	Name string `json:"name"`
 	// Tag is the classification tag to apply if the rule matches
-	Tag          string     `json:"tag"`
+	Tag string `json:"tag"`
 	// Parameters are shared values referenced in the rule (e.g., thresholds)
-	Parameters   []string   `json:"parameters"`
+	Parameters []string `json:"parameters"`
 	// Metrics are the job metrics required for this rule (e.g., "cpu_load", "mem_used")
-	Metrics      []string   `json:"metrics"`
+	Metrics []string `json:"metrics"`
 	// Requirements are boolean expressions that must be true for the rule to apply
-	Requirements []string   `json:"requirements"`
+	Requirements []string `json:"requirements"`
 	// Variables are computed values used in the rule expression
-	Variables    []Variable `json:"variables"`
+	Variables []Variable `json:"variables"`
 	// Rule is the boolean expression that determines if the job matches
-	Rule         string     `json:"rule"`
+	Rule string `json:"rule"`
 	// Hint is a template string that generates a message when the rule matches
-	Hint         string     `json:"hint"`
+	Hint string `json:"hint"`
 }
 
 type ruleInfo struct {
@@ -75,29 +84,29 @@ type ruleInfo struct {
 // This interface allows for easier testing and decoupling from the concrete repository implementation.
 type JobRepository interface {
 	// HasTag checks if a job already has a specific tag
-	HasTag(jobId int64, tagType string, tagName string) bool
+	HasTag(jobID int64, tagType string, tagName string) bool
 	// AddTagOrCreateDirect adds a tag to a job or creates it if it doesn't exist
-	AddTagOrCreateDirect(jobId int64, tagType string, tagName string) (tagId int64, err error)
+	AddTagOrCreateDirect(jobID int64, tagType string, tagName string) (tagID int64, err error)
 	// UpdateMetadata updates job metadata with a key-value pair
 	UpdateMetadata(job *schema.Job, key, val string) (err error)
 }
 
 // JobClassTagger classifies jobs based on configurable rules that evaluate job metrics and properties.
-// Rules are loaded from embedded JSON files and can be dynamically reloaded from a watched directory.
+// Rules are loaded from an external configuration directory and can be dynamically reloaded when files change.
 // When a job matches a rule, it is tagged with the corresponding classification and an optional hint message.
 type JobClassTagger struct {
 	// rules maps classification tags to their compiled rule information
-	rules           map[string]ruleInfo
+	rules map[string]ruleInfo
 	// parameters are shared values (e.g., thresholds) used across multiple rules
-	parameters      map[string]any
+	parameters map[string]any
 	// tagType is the type of tag ("jobClass")
-	tagType         string
+	tagType string
 	// cfgPath is the path to watch for configuration changes
-	cfgPath         string
+	cfgPath string
 	// repo provides access to job database operations
-	repo            JobRepository
+	repo JobRepository
 	// getStatistics retrieves job statistics for analysis
-	getStatistics   func(job *schema.Job) (map[string]schema.JobStatistics, error)
+	getStatistics func(job *schema.Job) (map[string]schema.JobStatistics, error)
 	// getMetricConfig retrieves metric configuration (limits) for a cluster
 	getMetricConfig func(cluster, subCluster string) map[string]*schema.Metric
 }
@@ -169,7 +178,7 @@ func (t *JobClassTagger) prepareRule(b []byte, fns string) {
 // EventMatch checks if a filesystem event should trigger configuration reload.
 // It returns true if the event path contains "jobclasses".
 func (t *JobClassTagger) EventMatch(s string) bool {
-	return strings.Contains(s, "jobclasses")
+	return strings.Contains(s, jobClassConfigDirMatch)
 }
 
 // EventCallback is triggered when the configuration directory changes.
@@ -181,9 +190,10 @@ func (t *JobClassTagger) EventCallback() {
 		cclog.Fatal(err)
 	}
 
-	if util.CheckFileExists(t.cfgPath + "/parameters.json") {
+	parametersFile := filepath.Join(t.cfgPath, parametersFileName)
+	if util.CheckFileExists(parametersFile) {
 		cclog.Info("Merge parameters")
-		b, err := os.ReadFile(t.cfgPath + "/parameters.json")
+		b, err := os.ReadFile(parametersFile)
 		if err != nil {
 			cclog.Warnf("prepareRule() > open file error: %v", err)
 		}
@@ -198,13 +208,13 @@ func (t *JobClassTagger) EventCallback() {
 
 	for _, fn := range files {
 		fns := fn.Name()
-		if fns != "parameters.json" {
+		if fns != parametersFileName {
 			cclog.Debugf("Process: %s", fns)
-			filename := fmt.Sprintf("%s/%s", t.cfgPath, fns)
+			filename := filepath.Join(t.cfgPath, fns)
 			b, err := os.ReadFile(filename)
 			if err != nil {
 				cclog.Warnf("prepareRule() > open file error: %v", err)
-				return
+				continue
 			}
 			t.prepareRule(b, fns)
 		}
@@ -213,7 +223,8 @@ func (t *JobClassTagger) EventCallback() {
 
 func (t *JobClassTagger) initParameters() error {
 	cclog.Info("Initialize parameters")
-	b, err := jobClassFiles.ReadFile("jobclasses/parameters.json")
+	parametersFile := filepath.Join(t.cfgPath, parametersFileName)
+	b, err := os.ReadFile(parametersFile)
 	if err != nil {
 		cclog.Warnf("prepareRule() > open file error: %v", err)
 		return err
@@ -227,13 +238,20 @@ func (t *JobClassTagger) initParameters() error {
 	return nil
 }
 
-// Register initializes the JobClassTagger by loading parameters and classification rules.
-// It loads embedded configuration files and sets up a file watch on ./var/tagger/jobclasses
-// if it exists, allowing for dynamic configuration updates without restarting the application.
-// Returns an error if the embedded configuration files cannot be read or parsed.
+// Register initializes the JobClassTagger by loading parameters and classification rules from external folder.
+// It sets up a file watch on ./var/tagger/jobclasses if it exists, allowing for
+// dynamic configuration updates without restarting the application.
+// Returns an error if the configuration path does not exist or cannot be read.
 func (t *JobClassTagger) Register() error {
-	t.cfgPath = "./var/tagger/jobclasses"
-	t.tagType = "jobClass"
+	if t.cfgPath == "" {
+		t.cfgPath = defaultJobClassConfigPath
+	}
+	t.tagType = tagTypeJobClass
+	t.rules = make(map[string]ruleInfo)
+
+	if !util.CheckFileExists(t.cfgPath) {
+		return fmt.Errorf("configuration path does not exist: %s", t.cfgPath)
+	}
 
 	err := t.initParameters()
 	if err != nil {
@@ -241,31 +259,28 @@ func (t *JobClassTagger) Register() error {
 		return err
 	}
 
-	files, err := jobClassFiles.ReadDir("jobclasses")
+	files, err := os.ReadDir(t.cfgPath)
 	if err != nil {
-		return fmt.Errorf("error reading app folder: %#v", err)
+		return fmt.Errorf("error reading jobclasses folder: %#v", err)
 	}
-	t.rules = make(map[string]ruleInfo)
+
 	for _, fn := range files {
 		fns := fn.Name()
-		if fns != "parameters.json" {
-			filename := fmt.Sprintf("jobclasses/%s", fns)
+		if fns != parametersFileName {
 			cclog.Infof("Process: %s", fns)
+			filename := filepath.Join(t.cfgPath, fns)
 
-			b, err := jobClassFiles.ReadFile(filename)
+			b, err := os.ReadFile(filename)
 			if err != nil {
 				cclog.Warnf("prepareRule() > open file error: %v", err)
-				return err
+				continue
 			}
 			t.prepareRule(b, fns)
 		}
 	}
 
-	if util.CheckFileExists(t.cfgPath) {
-		t.EventCallback()
-		cclog.Infof("Setup file watch for %s", t.cfgPath)
-		util.AddListener(t.cfgPath, t)
-	}
+	cclog.Infof("Setup file watch for %s", t.cfgPath)
+	util.AddListener(t.cfgPath, t)
 
 	t.repo = repository.GetJobRepository()
 	t.getStatistics = archive.GetStatistics