add ruleset

Author: JimhHan

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/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() (*ConditionChan, error) {
 	conds := NewConditionChan()
 
 	if len(rr.Domain) > 0 {
@@ -138,7 +138,7 @@ func (rr *RoutingRule) BuildCondition() (Condition, error) {
 		conds.Add(cond)
 	}
 
-	if conds.Len() == 0 {
+	if conds.Len() == 0 && rr.RuleSet == "" {
 		return nil, newError("this rule has no effective fields").AtWarning()
 	}
 
@@ -152,3 +152,23 @@ func (br *BalancingRule) Build(ohm outbound.Manager) (*Balancer, error) {
 		ohm:       ohm,
 	}, nil
 }
+
+func (rrs *RoutingRules) BuildCondition() (Condition, error) {
+	conds := NewOrConditionChan()
+
+	for _, rr := range rrs.Rules {
+		if rr.GetTag() != "" || rr.GetBalancingTag() != "" {
+			newError("ignoring tag in rule set").AtWarning().WriteToLog()
+		}
+		cond, err := rr.BuildCondition()
+		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
+}

app/router/config.pb.go

@@ -119,13 +119,19 @@ message RoutingRule {
   repeated string protocol = 9;
 
   string attributes = 15;
+  string rule_set = 17;
 }
 
 message BalancingRule {
   string tag = 1;
   repeated string outbound_selector = 2;
 }
 
+message RoutingRules {
+  string identifier = 1;
+  repeated RoutingRule rules = 2;
+}
+
 message Config {
   enum DomainStrategy {
     // Use domain as is.
@@ -143,4 +149,5 @@ message Config {
   DomainStrategy domain_strategy = 1;
   repeated RoutingRule rule = 2;
   repeated BalancingRule balancing_rule = 3;
+  repeated RoutingRules rule_sets = 4;
 }

app/router/config.proto

@@ -42,12 +42,30 @@ func (r *Router) Init(config *Config, d dns.Client, ohm outbound.Manager) error
 		r.balancers[rule.Tag] = balancer
 	}
 
+	var rulSets = make(map[string]Condition)
+	for _, rs := range config.RuleSets {
+		cond, err := rs.BuildCondition()
+		if err != nil {
+			return err
+		}
+		rulSets[rs.Identifier] = cond
+	}
+
 	r.rules = make([]*Rule, 0, len(config.Rule))
 	for _, rule := range config.Rule {
 		cond, err := rule.BuildCondition()
 		if err != nil {
 			return err
 		}
+
+		if rule.RuleSet != "" {
+			if ruleset, found := rulSets[rule.RuleSet]; found {
+				cond.Add(ruleset)
+			} else {
+				return newError("undefined rule set: " + rule.RuleSet).AtError()
+			}
+		}
+
 		rr := &Rule{
 			Condition: cond,
 			Tag:       rule.GetTag(),

app/router/router.go

@@ -37,11 +37,39 @@ func (r *BalancingRule) Build() (*router.BalancingRule, error) {
 	}, nil
 }
 
+type RuleSet struct {
+	Identifier string            `json:"tag"`
+	Rules      []json.RawMessage `json:"rules"`
+}
+
+func (r *RuleSet) Build() (*router.RoutingRules, error) {
+	if r.Identifier == "" {
+		return nil, newError("empty rule set tag")
+	}
+	if len(r.Rules) == 0 {
+		return nil, newError("empty rule set")
+	}
+
+	ruleSet := new(router.RoutingRules)
+	ruleSet.Identifier = r.Identifier
+
+	for _, rr := range r.Rules {
+		if rule, err := ParseRule(rr, true); err != nil {
+			return nil, err
+		} else {
+			ruleSet.Rules = append(ruleSet.Rules, rule)
+		}
+	}
+
+	return ruleSet, nil
+}
+
 type RouterConfig struct {
 	Settings       *RouterRulesConfig `json:"settings"` // Deprecated
 	RuleList       []json.RawMessage  `json:"rules"`
 	DomainStrategy *string            `json:"domainStrategy"`
 	Balancers      []*BalancingRule   `json:"balancers"`
+	RuleSets       []*RuleSet         `json:"rule_sets"`
 }
 
 func (c *RouterConfig) getDomainStrategy() router.Config_DomainStrategy {
@@ -78,7 +106,7 @@ func (c *RouterConfig) Build() (*router.Config, error) {
 	}
 
 	for _, rawRule := range rawRuleList {
-		rule, err := ParseRule(rawRule)
+		rule, err := ParseRule(rawRule, false)
 		if err != nil {
 			return nil, err
 		}
@@ -91,6 +119,13 @@ func (c *RouterConfig) Build() (*router.Config, error) {
 		}
 		config.BalancingRule = append(config.BalancingRule, balancer)
 	}
+	for _, rawRuleSet := range c.RuleSets {
+		rawRuleSet, err := rawRuleSet.Build()
+		if err != nil {
+			return nil, err
+		}
+		config.RuleSets = append(config.RuleSets, rawRuleSet)
+	}
 	return config, nil
 }
 
@@ -456,7 +491,7 @@ func toCidrList(ips StringList) ([]*router.GeoIP, error) {
 	return geoipList, nil
 }
 
-func parseFieldRule(msg json.RawMessage) (*router.RoutingRule, error) {
+func parseFieldRule(msg json.RawMessage, skipTargetCheck bool) (*router.RoutingRule, error) {
 	type RawFieldRule struct {
 		RouterRule
 		Domain     *StringList  `json:"domain"`
@@ -469,6 +504,7 @@ func parseFieldRule(msg json.RawMessage) (*router.RoutingRule, error) {
 		InboundTag *StringList  `json:"inboundTag"`
 		Protocols  *StringList  `json:"protocol"`
 		Attributes string       `json:"attrs"`
+		RuleSet    string       `json:"rule_set"`
 	}
 	rawFieldRule := new(RawFieldRule)
 	err := json.Unmarshal(msg, rawFieldRule)
@@ -477,17 +513,20 @@ func parseFieldRule(msg json.RawMessage) (*router.RoutingRule, error) {
 	}
 
 	rule := new(router.RoutingRule)
-	switch {
-	case len(rawFieldRule.OutboundTag) > 0:
-		rule.TargetTag = &router.RoutingRule_Tag{
-			Tag: rawFieldRule.OutboundTag,
-		}
-	case len(rawFieldRule.BalancerTag) > 0:
-		rule.TargetTag = &router.RoutingRule_BalancingTag{
-			BalancingTag: rawFieldRule.BalancerTag,
+
+	if !skipTargetCheck {
+		switch {
+		case len(rawFieldRule.OutboundTag) > 0:
+			rule.TargetTag = &router.RoutingRule_Tag{
+				Tag: rawFieldRule.OutboundTag,
+			}
+		case len(rawFieldRule.BalancerTag) > 0:
+			rule.TargetTag = &router.RoutingRule_BalancingTag{
+				BalancingTag: rawFieldRule.BalancerTag,
+			}
+		default:
+			return nil, newError("neither outboundTag nor balancerTag is specified in routing rule")
 		}
-	default:
-		return nil, newError("neither outboundTag nor balancerTag is specified in routing rule")
 	}
 
 	if rawFieldRule.Domain != nil {
@@ -550,17 +589,19 @@ func parseFieldRule(msg json.RawMessage) (*router.RoutingRule, error) {
 		rule.Attributes = rawFieldRule.Attributes
 	}
 
+	rule.RuleSet = rawFieldRule.RuleSet
+
 	return rule, nil
 }
 
-func ParseRule(msg json.RawMessage) (*router.RoutingRule, error) {
+func ParseRule(msg json.RawMessage, skipTargetCheck bool) (*router.RoutingRule, error) {
 	rawRule := new(RouterRule)
 	err := json.Unmarshal(msg, rawRule)
 	if err != nil {
 		return nil, newError("invalid router rule").Base(err)
 	}
 	if rawRule.Type == "field" {
-		fieldrule, err := parseFieldRule(msg)
+		fieldrule, err := parseFieldRule(msg, skipTargetCheck)
 		if err != nil {
 			return nil, newError("invalid field rule").Base(err)
 		}

infra/conf/router.go

@@ -391,9 +391,6 @@ func (c *Config) Override(o *Config, fn string) {
 	if o.LogConfig != nil {
 		c.LogConfig = o.LogConfig
 	}
-	if o.RouterConfig != nil {
-		c.RouterConfig = o.RouterConfig
-	}
 	if o.DNSConfig != nil {
 		c.DNSConfig = o.DNSConfig
 	}
@@ -462,6 +459,42 @@ func (c *Config) Override(o *Config, fn string) {
 			c.OutboundConfigs = o.OutboundConfigs
 		}
 	}
+
+	if o.RouterConfig != nil {
+		if len(o.RouterConfig.Balancers) > 0 {
+			c.RouterConfig.Balancers = o.RouterConfig.Balancers
+		}
+		if o.RouterConfig.DomainStrategy != nil {
+			c.RouterConfig.DomainStrategy = o.RouterConfig.DomainStrategy
+		}
+		if len(o.RouterConfig.RuleList) > 0 {
+			c.RouterConfig.RuleList = o.RouterConfig.RuleList
+		}
+		if o.RouterConfig.Settings != nil {
+			c.RouterConfig.Settings = o.RouterConfig.Settings
+		}
+
+		if len(o.RouterConfig.RuleSets) > 0 {
+			if len(c.RouterConfig.RuleSets) > 0 {
+				for _, set := range o.RouterConfig.RuleSets {
+					found := false
+					for _, cset := range c.RouterConfig.RuleSets {
+						if cset.Identifier == set.Identifier {
+							found = true
+						}
+					}
+
+					if found {
+						ctllog.Println("[", fn, "] found existing rule set: "+set.Identifier+", ignoring")
+					} else {
+						c.RouterConfig.RuleSets = append(c.RouterConfig.RuleSets, set)
+					}
+				}
+			} else {
+				c.RouterConfig.RuleSets = o.RouterConfig.RuleSets
+			}
+		}
+	}
 }
 
 func applyTransportConfig(s *StreamConfig, t *TransportConfig) {