Method loadRule

daemon/rule/loader.go:223–275

(fileName string)

}

func (l *Loader) loadRule(fileName string) error {
	raw, err := ioutil.ReadFile(fileName)
	if err != nil {
		return fmt.Errorf("Error while reading %s: %s", fileName, err)
	}
	l.Lock()
	defer l.Unlock()

	var r Rule
	err = json.Unmarshal(raw, &r)
	if err != nil {
		return fmt.Errorf("Error parsing rule from %s: %s", fileName, err)
	}
	raw = nil

	if oldRule, found := l.rules[r.Name]; found {
		l.cleanListsRule(oldRule)
	}

	if !r.Enabled {
		// XXX: we only parse and load the Data field if the rule is disabled and the Data field is not empty
		// the rule will remain disabled.
		if err = l.unmarshalOperatorList(&r.Operator); err != nil {
			return err
		}
	} else {
		if err := r.Operator.Compile(); err != nil {
			log.Warning("Operator.Compile() error: %s, %s (%s)", err, r.Operator.Data, r.Name)
			return fmt.Errorf("(1) Error compiling rule: %s", err)
		}
		if r.Operator.Type == List {
			for i := 0; i < len(r.Operator.List); i++ {
				if err := r.Operator.List[i].Compile(); err != nil {
					log.Warning("Operator.Compile() error: %s (%s)", err, r.Name)
					return fmt.Errorf("(1) Error compiling list rule: %s", err)
				}
			}
		}
	}
	if oldRule, found := l.rules[r.Name]; found {
		l.deleteOldRuleFromDisk(oldRule, &r)
	}

	log.Debug("Loaded rule from %s: %s", fileName, r.String())
	l.rules[r.Name] = &r
	l.sortRules()

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

	return nil
}

// deleteRule deletes a rule from memory if it has been deleted from disk.
// This is only called if fsnotify's Remove event is fired, thus it doesn't