aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--connection_handler_test.go4
-rw-r--r--routes.go6
-rw-r--r--rules_manager.go21
-rw-r--r--rules_manager_test.go170
4 files changed, 169 insertions, 32 deletions
diff --git a/connection_handler_test.go b/connection_handler_test.go
index dd097e4..9fe41af 100644
--- a/connection_handler_test.go
+++ b/connection_handler_test.go
@@ -186,8 +186,8 @@ func (rm TestRulesManager) GetRule(_ RowID) (Rule, bool) {
return Rule{}, false
}
-func (rm TestRulesManager) UpdateRule(_ context.Context, _ RowID, _ Rule) bool {
- return false
+func (rm TestRulesManager) UpdateRule(_ context.Context, _ RowID, _ Rule) (bool, error) {
+ return false, nil
}
func (rm TestRulesManager) GetRules() []Rule {
diff --git a/routes.go b/routes.go
index 111dd78..4599b8f 100644
--- a/routes.go
+++ b/routes.go
@@ -57,8 +57,10 @@ func ApplicationRoutes(engine *gin.Engine, rulesManager RulesManager) {
return
}
- updated := rulesManager.UpdateRule(c, id, rule)
- if !updated {
+ updated, err := rulesManager.UpdateRule(c, id, rule)
+ if err != nil {
+ badRequest(c, err)
+ } else if !updated {
notFound(c, UnorderedDocument{"id": id})
} else {
success(c, rule)
diff --git a/rules_manager.go b/rules_manager.go
index 57f8768..89b6153 100644
--- a/rules_manager.go
+++ b/rules_manager.go
@@ -64,7 +64,7 @@ type RulesManager interface {
LoadRules() error
AddRule(context context.Context, rule Rule) (RowID, error)
GetRule(id RowID) (Rule, bool)
- UpdateRule(context context.Context, id RowID, rule Rule) bool
+ UpdateRule(context context.Context, id RowID, rule Rule) (bool, error)
GetRules() []Rule
FillWithMatchedRules(connection *Connection, clientMatches map[uint][]PatternSlice, serverMatches map[uint][]PatternSlice)
DatabaseUpdateChannel() chan RulesDatabase
@@ -138,10 +138,15 @@ func (rm *rulesManagerImpl) GetRule(id RowID) (Rule, bool) {
return rule, isPresent
}
-func (rm *rulesManagerImpl) UpdateRule(context context.Context, id RowID, rule Rule) bool {
+func (rm *rulesManagerImpl) UpdateRule(context context.Context, id RowID, rule Rule) (bool, error) {
newRule, isPresent := rm.rules[id]
if !isPresent {
- return false
+ return false, nil
+ }
+
+ sameName, isPresent := rm.rulesByName[rule.Name]
+ if isPresent && sameName.ID != id {
+ return false, errors.New("already exists another rule with the same name")
}
updated, err := rm.storage.Update(Rules).Context(context).Filter(OrderedDocument{{"_id", id}}).
@@ -161,7 +166,7 @@ func (rm *rulesManagerImpl) UpdateRule(context context.Context, id RowID, rule R
rm.mutex.Unlock()
}
- return updated
+ return updated, nil
}
func (rm *rulesManagerImpl) GetRules() []Rule {
@@ -201,6 +206,7 @@ func (rm *rulesManagerImpl) validateAndAddRuleLocal(rule *Rule) error {
}
newPatterns := make([]*hyperscan.Pattern, 0, len(rule.Patterns))
+ duplicatePatterns := make(map[string]bool)
for i, pattern := range rule.Patterns {
if err := rm.validate.Struct(pattern); err != nil {
return err
@@ -210,7 +216,11 @@ func (rm *rulesManagerImpl) validateAndAddRuleLocal(rule *Rule) error {
if err != nil {
return err
}
- if existingPattern, isPresent := rm.patternsIds[compiledPattern.String()]; isPresent {
+ regex := compiledPattern.String()
+ if _, isPresent := duplicatePatterns[regex]; isPresent {
+ return errors.New("duplicate pattern")
+ }
+ if existingPattern, isPresent := rm.patternsIds[regex]; isPresent {
rule.Patterns[i].internalID = existingPattern
continue
}
@@ -219,6 +229,7 @@ func (rm *rulesManagerImpl) validateAndAddRuleLocal(rule *Rule) error {
rule.Patterns[i].internalID = id
compiledPattern.Id = id
newPatterns = append(newPatterns, compiledPattern)
+ duplicatePatterns[regex] = true
}
startId := len(rm.patterns)
diff --git a/rules_manager_test.go b/rules_manager_test.go
index 53d085d..68e3ae4 100644
--- a/rules_manager_test.go
+++ b/rules_manager_test.go
@@ -2,11 +2,12 @@ package main
import (
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"testing"
"time"
)
-func TestAddRule(t *testing.T) {
+func TestAddAndGetAllRules(t *testing.T) {
wrapper := NewTestStorageWrapper(t)
wrapper.AddCollection(Rules)
@@ -16,7 +17,7 @@ func TestAddRule(t *testing.T) {
timeout := time.Tick(1 * time.Second)
select {
- case database := <-rulesManager.databaseUpdated:
+ case database := <-rulesManager.DatabaseUpdateChannel():
assert.Equal(t, id, database.version)
case <-timeout:
t.Fatal("timeout")
@@ -26,17 +27,47 @@ func TestAddRule(t *testing.T) {
err := rulesManager.SetFlag(wrapper.Context, "FLAG{test}")
assert.NoError(t, err)
checkVersion(rulesManager.rulesByName["flag"].ID)
- emptyID, err := rulesManager.AddRule(wrapper.Context, Rule{Name: "empty", Color: "#fff"})
+ emptyRule := Rule{Name: "empty", Color: "#fff", Enabled: true}
+ emptyID, err := rulesManager.AddRule(wrapper.Context, emptyRule)
assert.NoError(t, err)
assert.NotNil(t, emptyID)
checkVersion(emptyID)
+ duplicateRule, err := rulesManager.AddRule(wrapper.Context, Rule{Name: "empty", Color: "#eee"})
+ assert.Error(t, err)
+ assert.Zero(t, duplicateRule)
+
+ invalidPattern, err := rulesManager.AddRule(wrapper.Context, Rule{
+ Name: "invalidPattern",
+ Color: "#eee",
+ Patterns: []Pattern{
+ {
+ Regex: "invalid)",
+ },
+ },
+ })
+ assert.Error(t, err)
+ assert.Zero(t, invalidPattern)
+
rule1 := Rule{
Name: "rule1",
Color: "#eee",
Patterns: []Pattern{
- {Regex: "nope", Flags: RegexFlags{Caseless: true}},
- },
+ {
+ Regex: "pattern1",
+ Flags: RegexFlags{
+ Caseless: true,
+ DotAll: true,
+ MultiLine: true,
+ SingleMatch: true,
+ Utf8Mode: true,
+ UnicodeProperty: true,
+ },
+ MinOccurrences: 1,
+ MaxOccurrences: 3,
+ Direction: DirectionBoth,
+ }},
+ Enabled: true,
}
rule1ID, err := rulesManager.AddRule(wrapper.Context, rule1)
assert.NoError(t, err)
@@ -47,31 +78,124 @@ func TestAddRule(t *testing.T) {
Name: "rule2",
Color: "#ddd",
Patterns: []Pattern{
- {Regex: "nope", Flags: RegexFlags{Caseless: true}},
- {Regex: "yep"},
+ {Regex: "pattern1"},
+ {Regex: "pattern2"},
},
+ Enabled: true,
}
rule2ID, err := rulesManager.AddRule(wrapper.Context, rule2)
assert.NoError(t, err)
assert.NotNil(t, rule2ID)
checkVersion(rule2ID)
- assert.Len(t, rulesManager.rules, 4)
- assert.Len(t, rulesManager.rulesByName, 4)
- assert.Len(t, rulesManager.patterns, 3)
- assert.Len(t, rulesManager.patternsIds, 3)
- assert.Equal(t, emptyID, rulesManager.rules[emptyID].ID)
- assert.Equal(t, emptyID, rulesManager.rulesByName["empty"].ID)
- assert.Len(t, rulesManager.rules[emptyID].Patterns, 0)
- assert.Equal(t, rule1ID, rulesManager.rules[rule1ID].ID)
- assert.Equal(t, rule1ID, rulesManager.rulesByName[rule1.Name].ID)
- assert.Len(t, rulesManager.rules[rule1ID].Patterns, 1)
- assert.Equal(t, 1, rulesManager.rules[rule1ID].Patterns[0].internalID)
- assert.Equal(t, rule2ID, rulesManager.rules[rule2ID].ID)
- assert.Equal(t, rule2ID, rulesManager.rulesByName[rule2.Name].ID)
- assert.Len(t, rulesManager.rules[rule2ID].Patterns, 2)
- assert.Equal(t, 1, rulesManager.rules[rule2ID].Patterns[0].internalID)
- assert.Equal(t, 2, rulesManager.rules[rule2ID].Patterns[1].internalID)
+ rule3 := Rule{
+ Name: "rule3",
+ Color: "#ccc",
+ Patterns: []Pattern{
+ {Regex: "pattern2"},
+ {Regex: "pattern3"},
+ },
+ Enabled: true,
+ }
+ rule3ID, err := rulesManager.AddRule(wrapper.Context, rule3)
+ assert.NoError(t, err)
+ assert.NotNil(t, rule3ID)
+ checkVersion(rule3ID)
+
+ checkRule := func(expected Rule, patternIDs []int) {
+ var rule Rule
+ err := wrapper.Storage.Find(Rules).Context(wrapper.Context).
+ Filter(OrderedDocument{{"_id", expected.ID}}).First(&rule)
+ require.NoError(t, err)
+
+ for i, id := range patternIDs {
+ rule.Patterns[i].internalID = id
+ }
+ assert.Equal(t, expected, rule)
+ assert.Equal(t, expected, rulesManager.rules[expected.ID])
+ assert.Equal(t, expected, rulesManager.rulesByName[expected.Name])
+ }
+
+ assert.Len(t, rulesManager.rules, 5)
+ assert.Len(t, rulesManager.rulesByName, 5)
+ assert.Len(t, rulesManager.patterns, 5)
+ assert.Len(t, rulesManager.patternsIds, 5)
+
+ emptyRule.ID = emptyID
+ rule1.ID = rule1ID
+ rule2.ID = rule2ID
+ rule3.ID = rule3ID
+
+ checkRule(emptyRule, []int{})
+ checkRule(rule1, []int{1})
+ checkRule(rule2, []int{2, 3})
+ checkRule(rule3, []int{3, 4})
+
+ assert.Len(t, rulesManager.GetRules(), 5)
+ assert.ElementsMatch(t, []Rule{rulesManager.rulesByName["flag"], emptyRule, rule1, rule2, rule3}, rulesManager.GetRules())
+
+ wrapper.Destroy(t)
+}
+
+func TestLoadAndUpdateRules(t *testing.T) {
+ wrapper := NewTestStorageWrapper(t)
+ wrapper.AddCollection(Rules)
+
+ expectedIds := []RowID{NewRowID(), NewRowID(), NewRowID(), NewRowID()}
+ rules := []interface{}{
+ Rule{ID: expectedIds[0], Name: "rule1", Color: "#fff", Patterns: []Pattern{
+ {Regex: "pattern1", Flags: RegexFlags{Caseless: true}, Direction: DirectionToClient, internalID: 0},
+ }},
+ Rule{ID: expectedIds[1], Name: "rule2", Color: "#eee", Patterns: []Pattern{
+ {Regex: "pattern2", MinOccurrences: 1, MaxOccurrences: 3, Direction: DirectionToServer, internalID: 1},
+ }},
+ Rule{ID: expectedIds[2], Name: "rule3", Color: "#ddd", Patterns: []Pattern{
+ {Regex: "pattern2", Direction: DirectionBoth, internalID: 1},
+ {Regex: "pattern3", Flags: RegexFlags{MultiLine: true}, internalID: 2},
+ }},
+ Rule{ID: expectedIds[3], Name: "rule4", Color: "#ccc", Patterns: []Pattern{
+ {Regex: "pattern3", internalID: 3},
+ }},
+ }
+ ids, err := wrapper.Storage.Insert(Rules).Context(wrapper.Context).Many(rules)
+ require.NoError(t, err)
+ assert.ElementsMatch(t, expectedIds, ids)
+
+ rulesManager := NewRulesManager(wrapper.Storage).(*rulesManagerImpl)
+ err = rulesManager.LoadRules()
+ require.NoError(t, err)
+
+ rule, isPresent := rulesManager.GetRule(NewRowID())
+ assert.Zero(t, rule)
+ assert.False(t, isPresent)
+
+ for _, objRule := range rules {
+ expected := objRule.(Rule)
+ rule, isPresent := rulesManager.GetRule(expected.ID)
+ assert.True(t, isPresent)
+ assert.Equal(t, expected, rule)
+ }
+
+ updated, err := rulesManager.UpdateRule(wrapper.Context, NewRowID(), Rule{})
+ assert.False(t, updated)
+ assert.NoError(t, err)
+
+ updated, err = rulesManager.UpdateRule(wrapper.Context, expectedIds[0], Rule{Name: "rule2", Color: "#fff"})
+ assert.False(t, updated)
+ assert.Error(t, err)
+
+ for _, objRule := range rules {
+ expected := objRule.(Rule)
+ expected.Name = expected.ID.Hex()
+ expected.Color = "#000"
+ updated, err := rulesManager.UpdateRule(wrapper.Context, expected.ID, expected)
+ assert.True(t, updated)
+ assert.NoError(t, err)
+
+ rule, isPresent := rulesManager.GetRule(expected.ID)
+ assert.True(t, isPresent)
+ assert.Equal(t, expected, rule)
+ }
wrapper.Destroy(t)
}
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2024-11-22 15:04:10 +0000