Add RuleSet

app/router/condition.go

@@ -41,6 +41,32 @@ func (v *ConditionChan) Len() int {
 	return len(*v)
 }
 
+type OrConditionChan []Condition
+
+func NewOrConditionChan() *OrConditionChan {
+	var condChan OrConditionChan = make([]Condition, 0, 8)
+	return &condChan
+}
+
+func (v *OrConditionChan) Add(cond Condition) *OrConditionChan {
+	*v = append(*v, cond)
+	return v
+}
+
+// Apply applies all conditions registered in this chan.
+func (v *OrConditionChan) Apply(ctx routing.Context) bool {
+	for _, cond := range *v {
+		if cond.Apply(ctx) {
+			return true
+		}
+	}
+	return false
+}
+
+func (v *OrConditionChan) Len() int {
+	return len(*v)
+}
+
 var matcherTypeMap = map[Domain_Type]strmatcher.Type{
 	Domain_Plain:  strmatcher.Substr,
 	Domain_Regex:  strmatcher.Regex,

app/router/condition_test.go

@@ -321,7 +321,7 @@ func TestRoutingRule(t *testing.T) {
 	}
 
 	for _, test := range cases {
-		cond, err := test.rule.BuildCondition()
+		cond, err := test.rule.BuildCondition(new(RulesetManager))
 		common.Must(err)
 
 		for _, subtest := range test.test {
@@ -444,3 +444,67 @@ func BenchmarkMultiGeoIPMatcher(b *testing.B) {
 		_ = matcher.Apply(ctx)
 	}
 }
+
+func TestRuleSet(t *testing.T) {
+	type ruleTest struct {
+		input  routing.Context
+		output bool
+	}
+
+	cases := []struct {
+		rule    *RoutingRule
+		manager *RulesetManager
+		test    []ruleTest
+	}{
+		{
+			&RoutingRule{RuleSet: "ruleset1", SourcePortList: &net.PortList{Range: []*net.PortRange{{From: 1000, To: 10000}}}},
+			func() *RulesetManager {
+				r := NewRSManager()
+				r.Add("ruleset1", &RoutingRules{Rules: []*RoutingRule{
+					{InboundTag: []string{"in1"}},
+				}, Identifier: "ruleset1"})
+				return r
+			}(),
+			[]ruleTest{
+				{withInbound(&session.Inbound{Tag: "in1", Source: net.TCPDestination(net.LocalHostIP, 8972)}), true},
+				{withInbound(&session.Inbound{Tag: "in1", Source: net.TCPDestination(net.LocalHostIP, 972)}), false},
+				{withInbound(&session.Inbound{Tag: "in2", Source: net.TCPDestination(net.LocalHostIP, 8972)}), false},
+				{withInbound(&session.Inbound{Tag: "in2", Source: net.TCPDestination(net.LocalHostIP, 972)}), false},
+			},
+		},
+		{
+			&RoutingRule{RuleSet: "ruleset1", SourcePortList: &net.PortList{Range: []*net.PortRange{{From: 5000, To: 10000}}}},
+			func() *RulesetManager {
+				r := NewRSManager()
+				r.Add("ruleset1", &RoutingRules{Rules: []*RoutingRule{
+					{SourcePortList: &net.PortList{Range: []*net.PortRange{{From: 1000, To: 10000}}}, RuleSet: "ruleset2"},
+				}, Identifier: "ruleset1"})
+				r.Add("ruleset2", &RoutingRules{Rules: []*RoutingRule{
+					{InboundTag: []string{"in1"}},
+				}, Identifier: "ruleset2"})
+				return r
+			}(),
+			[]ruleTest{
+				{withInbound(&session.Inbound{Tag: "in1", Source: net.TCPDestination(net.LocalHostIP, 8972)}), true},
+				{withInbound(&session.Inbound{Tag: "in1", Source: net.TCPDestination(net.LocalHostIP, 972)}), false},
+				{withInbound(&session.Inbound{Tag: "in2", Source: net.TCPDestination(net.LocalHostIP, 8972)}), false},
+				{withInbound(&session.Inbound{Tag: "in2", Source: net.TCPDestination(net.LocalHostIP, 972)}), false},
+				{withInbound(&session.Inbound{Tag: "in1", Source: net.TCPDestination(net.LocalHostIP, 3972)}), false},
+				{withInbound(&session.Inbound{Tag: "in2", Source: net.TCPDestination(net.LocalHostIP, 3972)}), false},
+			},
+		},
+	}
+
+	for _, test := range cases {
+		cond, err := test.rule.BuildCondition(test.manager)
+		common.Must(err)
+
+		for _, subtest := range test.test {
+			actual := cond.Apply(subtest.input)
+			if actual != subtest.output {
+				t.Error("test case failed: ", subtest.input, " expected ", subtest.output, " but got ", actual)
+			}
+		}
+	}
+
+}

app/router/config.go

@@ -63,7 +63,7 @@ func (r *Rule) Apply(ctx routing.Context) bool {
 	return r.Condition.Apply(ctx)
 }
 
-func (rr *RoutingRule) BuildCondition() (Condition, error) {
+func (rr *RoutingRule) BuildCondition(rsm *RulesetManager) (*ConditionChan, error) {
 	conds := NewConditionChan()
 
 	if len(rr.Domain) > 0 {
@@ -138,7 +138,15 @@ func (rr *RoutingRule) BuildCondition() (Condition, error) {
 		conds.Add(cond)
 	}
 
-	if conds.Len() == 0 {
+	if rr.RuleSet != "" {
+		if rsCond, err := rsm.getRuleSet(rr.RuleSet); err != nil {
+			return nil, err
+		} else {
+			conds.Add(rsCond)
+		}
+	}
+
+	if conds.Len() == 0 && rr.RuleSet == "" {
 		return nil, newError("this rule has no effective fields").AtWarning()
 	}
 
@@ -152,3 +160,27 @@ func (br *BalancingRule) Build(ohm outbound.Manager) (*Balancer, error) {
 		ohm:       ohm,
 	}, nil
 }
+
+func (rrs *RoutingRules) BuildCondition(rsm *RulesetManager) (Condition, error) {
+	conds := NewOrConditionChan()
+
+	for _, rr := range rrs.Rules {
+		if rr.GetTag() != "" || rr.GetBalancingTag() != "" {
+			newError("ignoring tag in rule set").AtWarning().WriteToLog()
+		}
+
+		if rr.RuleSet == rrs.Identifier {
+			return nil, newError("import cycle found for tag: " + rrs.Identifier)
+		}
+		cond, err := rr.BuildCondition(rsm)
+		if err != nil {
+			return nil, err
+		}
+		conds.Add(cond)
+	}
+	if conds.Len() == 0 {
+		return nil, newError("this rule set has no effective fields").AtWarning()
+	}
+
+	return conds, nil
+}