Method replaceUserRule

daemon/rule/loader.go:389–432

(rule *Rule)

}

func (l *Loader) replaceUserRule(rule *Rule) (err error) {
	l.Lock()
	oldRule, found := l.rules[rule.Name]
	l.Unlock()

	if found {
		// If the rule has changed from Always (saved on disk) to !Always (temporary),
		// we need to delete the rule from disk and keep it in memory.
		l.deleteOldRuleFromDisk(oldRule, rule)

		// delete loaded lists, if this is a rule of type Lists
		l.cleanListsRule(oldRule)
	}

	if err := l.unmarshalOperatorList(&rule.Operator); err != nil {
		log.Error(err.Error())
	}

	if rule.Enabled {
		if err := rule.Operator.Compile(); err != nil {
			log.Warning("Operator.Compile() error: %s: %s", err, rule.Operator.Data)
			return fmt.Errorf("(2) error compiling rule: %s", err)
		}

		if rule.Operator.Type == List {
			for i := 0; i < len(rule.Operator.List); i++ {
				if err := rule.Operator.List[i].Compile(); err != nil {
					log.Warning("Operator.Compile() error: %s: ", err)
					return fmt.Errorf("(2) error compiling list rule: %s", err)
				}
			}
		}
	}
	l.Lock()
	l.rules[rule.Name] = rule
	l.sortRules()
	l.Unlock()

	if rule.Enabled && l.isTemporary(rule) {
		err = l.scheduleTemporaryRule(*rule)
	}

	return err
}

func (l *Loader) scheduleTemporaryRule(rule Rule) error {
	tTime, err := time.ParseDuration(string(rule.Duration))